From 64bb54e4f52a558a4e5c624a8b238b0f435c6242 Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 20 Aug 2025 09:35:03 -0600 Subject: [PATCH 01/17] added the herbie forecast script --- data/ercot_mora_solar_sites.csv | 293 ++++++++++++++++++++++++++++++ data/generate_herbie_forecasts.py | 164 +++++++++++++++++ data/merge_conus_nsrdb.py | 107 +++++++++++ data/run_pvdrdb_sites_pvwatts.py | 155 ++++++++++++++++ 4 files changed, 719 insertions(+) create mode 100644 data/ercot_mora_solar_sites.csv create mode 100644 data/generate_herbie_forecasts.py create mode 100644 data/merge_conus_nsrdb.py create mode 100644 data/run_pvdrdb_sites_pvwatts.py diff --git a/data/ercot_mora_solar_sites.csv b/data/ercot_mora_solar_sites.csv new file mode 100644 index 00000000..64a18eaa --- /dev/null +++ b/data/ercot_mora_solar_sites.csv @@ -0,0 +1,293 @@ +UNIT NAME,UNIT CODE,COUNTY,INSTALLED CAPACITY RATING (MW) +7V SOLAR,7RNCHSLR_UNIT1,FAYETTE,139.5 +7V SOLAR U2,7RNCHSLR_UNIT2,FAYETTE,95.54 +7V SOLAR U3,7RNCHSLR_UNIT3,FAYETTE,5.57 +ACACIA SOLAR,ACACIA_UNIT_1,PRESIDIO,10.0 +ALEXIS SOLAR,ALEXIS_ALEXIS,BROOKS,10.0 +ANDROMEDA SOLAR U1,ANDMDSLR_UNIT1,SCURRY,158.8 +ANDROMEDA SOLAR U2,ANDMDSLR_UNIT2,SCURRY,162.4 +ANGELO SOLAR,ANG_SLR_UNIT1,TOM GREEN,195.41 +ANSON SOLAR U1,ANSON1_UNIT1,JONES,100.8 +ANSON SOLAR U2,ANSON1_UNIT2,JONES,100.8 +ARAGORN SOLAR,ARAGORN_UNIT1,CULBERSON,188.2 +AUREOLA SOLAR U1,AURO_SLR_UNIT1,MILAM,201.66 +AZURE SKY SOLAR U1,AZURE_SOLAR1,HASKELL,74.9 +AZURE SKY SOLAR U2,AZURE_SOLAR2,HASKELL,153.5 +BHE SOLAR PEARL PROJECT (SIRIUS 2),SIRIUS_UNIT2,PECOS,50.0 +BIG ELM SOLAR,BELM_SLR_UNIT1,BELL,200.99 +BLUEBELL SOLAR (CAPRICORN RIDGE SOLAR),CAPRIDG4_BB_PV,STERLING,30.0 +BLUEBELL SOLAR II 1 (CAPRICORN RIDGE 4),CAPRIDG4_BB2_PV1,STERLING,100.0 +BLUEBELL SOLAR II 2 (CAPRICORN RIDGE 4),CAPRIDG4_BB2_PV2,STERLING,15.0 +BNB LAMESA SOLAR (PHASE I),LMESASLR_UNIT1,DAWSON,101.6 +BNB LAMESA SOLAR (PHASE II),LMESASLR_IVORY,DAWSON,50.0 +BOVINE SOLAR LLC,BOVINE_BOVINE,AUSTIN,5.0 +BOVINE SOLAR LLC,BOVINE2_BOVINE2,AUSTIN,5.0 +BPL FILES SOLAR,FILESSLR_PV1,HILL,146.09 +BRIGHTSIDE SOLAR,BRIGHTSD_UNIT1,BEE,53.4 +BRONSON SOLAR I,BRNSN_BRNSN,FORT BEND,5.0 +BRONSON SOLAR II,BRNSN2_BRNSN2,FORT BEND,5.0 +CASTLE GAP SOLAR,CASL_GAP_UNIT1,UPTON,180.0 +CATAN SOLAR,CS10_CATAN,KARNES,10.0 +CHISUM SOLAR,CHISUM_CHISUM,LAMAR,10.0 +COMMERCE_SOLAR,X443PV1_SWRI_PV1,BEXAR,5.0 +CONIGLIO SOLAR,CONIGLIO_UNIT1,FANNIN,125.7 +CORAL SOLAR U1,CORALSLR_SOLAR1,FALLS,97.7 +CORAL SOLAR U2,CORALSLR_SOLAR2,FALLS,56.3 +CORAZON SOLAR PHASE I,CORAZON_UNIT1,WEBB,202.6 +CROWN SOLAR,CRWN_SLR_UNIT1,FALLS,101.3 +DANCIGER SOLAR U1,DAG_UNIT1,BRAZORIA,101.4 +DANCIGER SOLAR U2,DAG_UNIT2,BRAZORIA,101.4 +DILEO SOLAR,DILEOSLR_UNIT1,BOSQUE,71.4 +EAST BLACKLAND SOLAR (PFLUGERVILLE SOLAR),E_BLACK_UNIT_1,TRAVIS,144.0 +EDDY SOLAR II,EDDYII_EDDYII,MCLENNAN,10.0 +EIFFEL SOLAR,EIFSLR_UNIT1,LAMAR,241.0 +ELARA SOLAR,ELARA_SL_UNIT1,FRIO,132.4 +ELLIS SOLAR,ELLISSLR_UNIT1,ELLIS,81.3 +EMERALD GROVE SOLAR (PECOS SOLAR POWER I),EGROVESL_UNIT1,CRANE,109.5 +EUNICE SOLAR U1,EUNICE_PV1,ANDREWS,189.6 +EUNICE SOLAR U2,EUNICE_PV2,ANDREWS,237.1 +FENCE POST SOLAR U1,FENCESLR_SOLAR1,NAVARRO,138.88 +FENCE POST SOLAR U2,FENCESLR_SOLAR2,NAVARRO,97.98 +FIFTH GENERATION SOLAR 1,FIFTHGS1_FGSOLAR1,TRAVIS,6.8 +FIVE WELLS SOLAR U1,FIVEWSLR_UNIT1,BELL,194.42 +FIVE WELLS SOLAR U2,FIVEWSLR_UNIT2,BELL,126.97 +FOWLER RANCH,FWLR_SLR_UNIT1,CRANE,152.5 +FRYE SOLAR U1,FRYE_SLR_UNIT1,SWISHER,250.9 +FRYE SOLAR U2,FRYE_SLR_UNIT2,SWISHER,251.1 +FS BARILLA SOLAR-PECOS,HOVEY_UNIT1,PECOS,22.0 +FS EAST PECOS SOLAR,BOOTLEG_UNIT1,PECOS,126.0 +GALLOWAY 1 SOLAR,GALLOWAY_SOLAR1,CONCHO,250.0 +GALLOWAY 2 SOLAR,GALLOWAY_SOLAR2,CONCHO,111.1 +GOLINDA SOLAR,GOLINDA_UNIT1,FALLS,101.1 +GREASEWOOD SOLAR 1,GREASWOD_UNIT1,PECOS,126.3 +GREASEWOOD SOLAR 2,GREASWOD_UNIT2,PECOS,132.2 +GRIFFIN SOLAR,GRIFFIN_GRIFFIN,MCLENNAN,5.0 +GRIZZLY RIDGE SOLAR,GRIZZLY_SOLAR1,HAMILTON,101.7 +HALO SOLAR,HALO_SLR_UNIT1,BELL,251.15 +HIGHWAY 56,HWY56_HWY56,GRAYSON,5.3 +HM SEALY SOLAR 1,SEALY_1UNIT,AUSTIN,1.6 +HOLLYWOOD SOLAR U1,HOL_UNIT1,WHARTON,176.14 +HOLLYWOOD SOLAR U2,HOL_UNIT2,WHARTON,178.95 +HOLSTEIN SOLAR 1,HOLSTEIN_SOLAR1,NOLAN,102.2 +HOLSTEIN SOLAR 2,HOLSTEIN_SOLAR2,NOLAN,102.3 +HOPKINS SOLAR U1,HOPKNSLR_UNIT1,HOPKINS,175.35 +HOPKINS SOLAR U2,HOPKNSLR_UNIT2,HOPKINS,76.17 +HORIZON SOLAR,HRZN_SLR_UNIT1,FRIO,203.5 +IMPACT SOLAR,IMPACT_UNIT1,LAMAR,198.5 +JADE SOLAR U1,JADE_SLR_UNIT1,SCURRY,158.8 +JADE SOLAR U2,JADE_SLR_UNIT2,SCURRY,162.4 +JUNO SOLAR PHASE I,JUNO_UNIT1,BORDEN,162.1 +JUNO SOLAR PHASE II,JUNO_UNIT2,BORDEN,143.5 +KELLAM SOLAR,KELAM_SL_UNIT1,VAN ZANDT,59.8 +LAPETUS SOLAR,LAPETUS_UNIT_1,ANDREWS,100.7 +LEON,LEON_LEON,HUNT,10.0 +LILY SOLAR,LILY_SOLAR1,KAUFMAN,147.6 +LONG DRAW SOLAR U1,LGDRAW_S_UNIT1_1,BORDEN,98.5 +LONG DRAW SOLAR U2,LGDRAW_S_UNIT1_2,BORDEN,128.3 +LONGBOW SOLAR,LON_SOLAR1,BRAZORIA,78.2 +MANDORLA SOLAR,MAND_SLR_UNIT1,MILAM,251.45 +MARLIN,MARLIN_MARLIN,FALLS,5.3 +MARS SOLAR (DG),MARS_MARS,WEBB,10.0 +MCLEAN (SHAKES) SOLAR,MCLNSLR_UNIT1,DIMMIT,207.4 +MISAE SOLAR U1,MISAE_UNIT1,CHILDRESS,121.4 +MISAE SOLAR U2,MISAE_UNIT2,CHILDRESS,118.6 +MUSTANG CREEK SOLAR U1,MUSTNGCK_SOLAR1,JACKSON,61.0 +MUSTANG CREEK SOLAR U2,MUSTNGCK_SOLAR2,JACKSON,91.25 +NEBULA SOLAR (RAYOS DEL SOL) U1,NEBULA_UNIT1,CAMERON,137.5 +NOBLE SOLAR U1,NOBLESLR_SOLAR1,DENTON,148.8 +NOBLE SOLAR U2,NOBLESLR_SOLAR2,DENTON,130.2 +NORTH GAINESVILLE,NGNSVL_NGAINESV,COOKE,5.2 +OCI ALAMO 1 SOLAR,OCI_ALM1_UNIT1,BEXAR,39.18 +OCI ALAMO 4 SOLAR-BRACKETVILLE,ECLIPSE_UNIT1,KINNEY,37.62 +OCI ALAMO 5 (DOWNIE RANCH),HELIOS_UNIT1,UVALDE,100.0 +OCI ALAMO 6 (SIRIUS/WEST TEXAS),SIRIUS_UNIT1,PECOS,110.2 +OCI ALAMO 7 (PAINT CREEK),SOLARA_UNIT1,HASKELL,112.0 +PHOEBE SOLAR 1,PHOEBE_UNIT1,WINKLER,125.14 +PHOEBE SOLAR 2,PHOEBE_UNIT2,WINKLER,128.05 +PHOENIX SOLAR,PHOENIX_UNIT1,FANNIN,83.9 +PISGAH RIDGE SOLAR U1,PISGAH_SOLAR1,NAVARRO,189.4 +PISGAH RIDGE SOLAR U2,PISGAH_SOLAR2,NAVARRO,64.4 +PITTS DUDIK SOLAR U1,PITTSDDK_UNIT1,HILL,49.6 +PORTER SOLAR U1,PORT_SLR_UNIT1,DENTON,245.83 +POWERFIN KINGSBERY,PFK_PFKPV,TRAVIS,2.6 +PROSPERO SOLAR 1 U1,PROSPERO_UNIT1,ANDREWS,153.6 +PROSPERO SOLAR 1 U2,PROSPERO_UNIT2,ANDREWS,150.0 +PROSPERO SOLAR 2 U1,PRSPERO2_UNIT1,ANDREWS,126.5 +PROSPERO SOLAR 2 U2,PRSPERO2_UNIT2,ANDREWS,126.4 +QUEEN SOLAR U1,QUEEN_SL_SOLAR1,UPTON,102.5 +QUEEN SOLAR U2,QUEEN_SL_SOLAR2,UPTON,102.5 +QUEEN SOLAR U3,QUEEN_SL_SOLAR3,UPTON,97.5 +QUEEN SOLAR U4,QUEEN_SL_SOLAR4,UPTON,107.5 +RADIAN SOLAR U1,RADN_SLR_UNIT1,BROWN,161.41 +RADIAN SOLAR U2,RADN_SLR_UNIT2,BROWN,166.02 +RAMBLER SOLAR,RAMBLER_UNIT1,TOM GREEN,211.19 +RATLIFF SOLAR (CONCHO VALLEY SOLAR),RATLIFF_SOLAR1,TOM GREEN,162.43 +RE ROSEROCK SOLAR 1,REROCK_UNIT1,PECOS,78.75 +RE ROSEROCK SOLAR 2,REROCK_UNIT2,PECOS,78.75 +REDBARN SOLAR 1 (RE MAPLEWOOD 2A SOLAR),REDBARN_UNIT_1,PECOS,222.0 +REDBARN SOLAR 2 (RE MAPLEWOOD 2B SOLAR),REDBARN_UNIT_2,PECOS,28.0 +RENEWABLE ENERGY ALTERNATIVES-CCS1,COSERVSS_CSS1,DENTON,2.0 +RIGGINS (SE BUCKTHORN WESTEX SOLAR),RIGGINS_UNIT1,PECOS,155.44 +RIPPEY SOLAR,RIPPEY_UNIT1,COOKE,59.8 +ROWLAND SOLAR I,ROW_UNIT1,FORT BEND,101.7 +ROWLAND SOLAR II,ROW_UNIT2,FORT BEND,200.7 +SOLAIREHOLMAN 1,LASSO_UNIT1,BREWSTER,50.0 +SPARTA SOLAR U1,SPARTA_UNIT1,BEE,147.5 +SPARTA SOLAR U2,SPARTA_UNIT2,BEE,104.9 +SP-TX-12-PHASE B,SPTX12B_UNIT1,UPTON,157.5 +STERLING,STRLING_STRLING,HUNT,10.0 +STRATEGIC SOLAR 1,STRATEGC_UNIT1,ELLIS,135.0 +SUN VALLEY U1,SUNVASLR_UNIT1,HILL,165.75 +SUN VALLEY U2,SUNVASLR_UNIT2,HILL,86.19 +SUNRAY,SUN_SLR_UNIT_1,UVALDE,203.5 +TAVENER U1 (FORT BEND SOLAR)                                                                                                                                                                                                                                   ,TAV_UNIT1,FORT BEND,149.5 +TAVENER U2 (FORT BEND SOLAR)                                                                                                                                                                                                                                   ,TAV_UNIT2,FORT BEND,100.4 +TAYGETE SOLAR 1 U1,TAYGETE_UNIT1,PECOS,125.9 +TAYGETE SOLAR 1 U2,TAYGETE_UNIT2,PECOS,128.9 +TAYGETE SOLAR 2 U1,TAYGETE2_UNIT1,PECOS,101.9 +TAYGETE SOLAR 2 U2,TAYGETE2_UNIT2,PECOS,101.9 +TEXAS SOLAR NOVA U1,NOVA1SLR_UNIT1,KENT,126.81 +TEXAS SOLAR NOVA U2,NOVA1SLR_UNIT2,KENT,126.7 +TIERRA BONITA SOLAR U1,TRBT_SLR_PV1,PECOS,150.0 +TIERRA BONITA SOLAR U2,TRBT_SLR_PV2,PECOS,156.9 +TITAN SOLAR (IP TITAN) U1,TI_SOLAR_UNIT1,CULBERSON,136.8 +TITAN SOLAR (IP TITAN) U2,TI_SOLAR_UNIT2,CULBERSON,131.1 +TPE ERATH SOLAR,ERATH_ERATH21,ERATH,10.0 +TRUE NORTH SOLAR U1,TNS_SLR_UNIT1,FALLS,119.35 +TRUE NORTH SOLAR U2,TNS_SLR_UNIT2,FALLS,119.45 +VANCOURT SOLAR,VANCOURT_UNIT1,CAMERON,45.7 +VISION SOLAR 1,VISION_UNIT1,NAVARRO,129.2 +WAGYU SOLAR,WGU_UNIT1,BRAZORIA,120.0 +WALNUT SPRINGS,WLNTSPRG_1UNIT,BOSQUE,10.0 +WAYMARK SOLAR,WAYMARK_UNIT1,UPTON,182.0 +WEBBERVILLE SOLAR,WEBBER_S_WSP1,TRAVIS,26.7 +WEST MOORE II,WMOOREII_WMOOREII,GRAYSON,5.0 +WEST OF PECOS SOLAR,W_PECOS_UNIT1,REEVES,100.0 +WESTORIA SOLAR U1,WES_UNIT1,BRAZORIA,101.6 +WESTORIA SOLAR U2,WES_UNIT2,BRAZORIA,101.6 +WHITESBORO,WBORO_WHTSBORO,GRAYSON,5.0 +WHITESBORO II,WBOROII_WHBOROII,GRAYSON,5.0 +WHITEWRIGHT,WHTRT_WHTRGHT,FANNIN,10.0 +YELLOW JACKET SOLAR,YLWJACKET_YLWJACKET,BOSQUE,5.0 +ZIER SOLAR,ZIER_SLR_PV1,KINNEY,161.28 +ASH CREEK SOLAR U1,ASCK_SLR_SOLAR1,HILL,206.8 +ASH CREEK SOLAR U2,ASCK_SLR_SOLAR2,HILL,210.94 +AZALEA SPRINGS SOLAR,AZSP_SLR_SOLAR1,ANGELINA,181.0 +BAKER BRANCH SOLAR U1,BAKE_SLR_UNIT1,LAMAR,234.84 +BAKER BRANCH SOLAR U2,BAKE_SLR_UNIT2,LAMAR,234.57 +BIG STAR SOLAR U1,BIG_STAR_UNIT1,BASTROP,132.27 +BIG STAR SOLAR U2,BIG_STAR_UNIT2,BASTROP,70.83 +BLEVINS SOLAR U2,BLVN_SLR_SOLAR2,FALLS,132.02 +BLEVINS SOLAR U3,BLVN_SLR_SOLAR3,FALLS,139.74 +BLUE JAY SOLAR I,BLUEJAY_UNIT1,GRIMES,69.0 +BLUE JAY SOLAR II,BLUEJAY_UNIT2,GRIMES,141.0 +BRIGHT ARROW SOLAR U1,BR_ARROW_UNIT1,HOPKINS,127.3 +BRIGHT ARROW SOLAR U2,BR_ARROW_UNIT2,HOPKINS,173.9 +BUFFALO CREEK (OLD 300 SOLAR CENTER) U1,BCK_UNIT1,FORT BEND,217.5 +BUFFALO CREEK (OLD 300 SOLAR CENTER) U2,BCK_UNIT2,FORT BEND,221.3 +CHEVRON ALLEN SOLAR (HAYHURST TEXAS SOLAR),CHAL_SLR_SOLAR1,CULBERSON,25.22 +CHILLINGHAM SOLAR U1,CHIL_SLR_SOLAR1,BELL,174.3 +CHILLINGHAM SOLAR U2,CHIL_SLR_SOLAR2,BELL,178.1 +COMPADRE SOLAR U1,CMPD_SLR_SOLAR1,HILL,195.17 +COMPADRE SOLAR U2,CMPD_SLR_SOLAR2,HILL,211.37 +COTTONWOOD BAYOU SOLAR I U1,CTW_SOLAR1,BRAZORIA,175.69 +COTTONWOOD BAYOU SOLAR I U2,CTW_SOLAR2,BRAZORIA,175.71 +DAMAZO (SECOND DIVISION) SOLAR,DMA_SOLAR1,BRAZORIA,100.2 +DANISH FIELDS SOLAR U1,DAN_UNIT1,WHARTON,301.3 +DANISH FIELDS SOLAR U2,DAN_UNIT2,WHARTON,151.0 +DANISH FIELDS SOLAR U3,DAN_UNIT3,WHARTON,150.5 +DELILAH SOLAR 1 U1,DELILA_1_G1,LAMAR,153.54 +DELILAH SOLAR 1 U2,DELILA_1_G2,LAMAR,153.54 +DELILAH SOLAR 2 U1,DELILA_2_G1,RED RIVER,107.09 +DELILAH SOLAR 2 U2,DELILA_2_G2,RED RIVER,103.4 +DELILAH SOLAR 2 U3,DELILA_2_G3,RED RIVER,107.09 +DRY CREEK SOLAR I,DRCK_SLR_SOLAR1,HENDERSON,200.1 +EASTBELL MILAM SOLAR,EBELLSLR_UNIT1,MILAM,244.86 +EASTBELL MILAM SOLAR II,EBELLSL2_UNIT1,MILAM,150.6 +ELIZA SOLAR,ELZA_SLR_SOLAR1,KAUFMAN,151.7 +ESTONIAN SOLAR FARM U1,ESTONIAN_SOLAR1,DELTA,88.4 +ESTONIAN SOLAR FARM U2,ESTONIAN_SOLAR2,DELTA,114.4 +FIGHTING JAYS SOLAR U1,JAY_UNIT1,FORT BEND,179.6 +FIGHTING JAYS SOLAR U2,JAY_UNIT2,FORT BEND,171.9 +GRANSOLAR TEXAS ONE,GRAN_SLR_UNIT1,MILAM,50.19 +GRIMES COUNTY SOLAR U1,GRIM_SLR_UNIT1,GRIMES,104.46 +GRIMES COUNTY SOLAR U2,GRIM_SLR_UNIT2,GRIMES,79.87 +GRIMES COUNTY SOLAR U3,GRIM_SLR_UNIT3,GRIMES,26.92 +HORNET SOLAR U1,HRNT_SLR_UNIT1,SWISHER,202.09 +HORNET SOLAR U2,HRNT_SLR_UNIT2,SWISHER,200.54 +HORNET SOLAR U3,HRNT_SLR_UNIT3,SWISHER,201.18 +HOVEY (BARILLA SOLAR 1B),HOVEY_UNIT2,PECOS,7.41 +JUNGMANN SOLAR,JUNG_SLR_UNIT1,MILAM,40.21 +MARKUM SOLAR,MRKM_SLR_PV1,MCLENNAN,161.5 +MERCURY SOLAR U1,MERCURY_PV1,HILL,203.5 +MERCURY SOLAR U2,MERCURY_PV2,HILL,203.5 +MORROW LAKE SOLAR,MROW_SLR_SOLAR1,FRIO,202.2 +MYRTLE SOLAR U1,MYR_UNIT1,BRAZORIA,171.6 +MYRTLE SOLAR U2,MYR_UNIT2,BRAZORIA,149.6 +ORANGE GROVE SOLAR,OGS_SLR_UNIT1,JIM WELLS,130.6 +OUTPOST SOLAR U1,OUTP_SLR_UNIT1,WEBB,257.95 +OUTPOST SOLAR U2,OUTP_SLR_UNIT2,WEBB,259.11 +PEREGRINE SOLAR U1,PERE_SLR_UNIT1,GOLIAD,152.83 +PEREGRINE SOLAR U2,PERE_SLR_UNIT2,GOLIAD,148.28 +PHOTON SOLAR U1,PHO_SOLAR1,WHARTON,129.59 +PHOTON SOLAR U2,PHO_SOLAR2,WHARTON,106.07 +PHOTON SOLAR U3,PHO_SOLAR3,WHARTON,109.99 +PHOTON SOLAR U4,PHO_SOLAR4,WHARTON,105.98 +PLAINVIEW SOLAR (RAMSEY SOLAR) U1,PLN_UNIT1,WHARTON,270.0 +PLAINVIEW SOLAR (RAMSEY SOLAR) U2,PLN_UNIT2,WHARTON,270.0 +ROSELAND SOLAR U1,ROSELAND_SOLAR1,FALLS,254.0 +ROSELAND SOLAR U2,ROSELAND_SOLAR2,FALLS,137.8 +ROSELAND SOLAR U3,ROSELAND_SOLAR3,FALLS,116.2 +SAMSON SOLAR 1 U1,SAMSON_1_G1,LAMAR,128.42 +SAMSON SOLAR 1 U2,SAMSON_1_G2,LAMAR,128.42 +SAMSON SOLAR 2 U1,SAMSON_1_G3,LAMAR,101.52 +SAMSON SOLAR 2 U2,SAMSON_1_G4,LAMAR,101.52 +SAMSON SOLAR 3 U1,SAMSON_3_G1,LAMAR,128.42 +SAMSON SOLAR 3 U2,SAMSON_3_G2,LAMAR,128.42 +SBRANCH SOLAR PROJECT,SBE_UNIT1,WHARTON,233.5 +SIGNAL SOLAR,SIG_SLR_UNIT1,HUNT,51.6 +STAMPEDE SOLAR U1,STAM_SLR_SOLAR1,HOPKINS,77.75 +STAMPEDE SOLAR U2,STAM_SLR_SOLAR2,HOPKINS,178.55 +STARR SOLAR RANCH U1,STAR_SLR_UNIT1,STARR,70.45 +STARR SOLAR RANCH U2,STAR_SLR_UNIT2,STARR,66.28 +STONERIDGE SOLAR U1,STRG_SLR_UNIT1,MILAM,184.1 +STONERIDGE SOLAR U2,STRG_SLR_UNIT2,MILAM,17.5 +SWIFT AIR SOLAR,SWFT_SLR_UNIT1,ECTOR,146.5 +TEXAS SOLAR NOVA 2 U1,NOVA2SLR_UNIT1,KENT,202.37 +TRES BAHIAS SOLAR,TREB_SLR_SOLAR1,CALHOUN,196.29 +TULSITA SOLAR U1,TUL_SLR_UNIT1,GOLIAD,128.08 +TULSITA SOLAR U2,TUL_SLR_UNIT2,GOLIAD,128.12 +XE MURAT [ADLONG] SOLAR,ADL_SOLAR1,HARRIS,60.14 +PHOEBE SOLAR 1,PHOEBE_UNIT1,WINKLER,125.04 +PHOEBE SOLAR 2,PHOEBE_UNIT2,WINKLER,127.95 +FIGHTING JAYS SOLAR U1,JAY_UNIT1,FORT BEND,179.5 +FIGHTING JAYS SOLAR U2,JAY_UNIT2,FORT BEND,171.8 +HORNET SOLAR U1,HRNT_SLR_UNIT1,SWISHER,200.65 +CASCADE SOLAR I,CASCADE_CASCADE,WHARTON,5.0 +CASCADE SOLAR II,CASCADE2_CASCADE2,WHARTON,5.0 +LAMPWICK SOLAR,LAMPWICK_LAMPWICK,MENARD,7.5 +MARLIN,MARLIN_MARLIN,FALLS,5.28 +TPE ERATH SOLAR,ERATH_ERATH21,ERATH,9.99 +CASCADE SOLAR I,CASCADE_CASCADE,WHARTON,177.52 +BLUE WING 1 SOLAR,DG_BROOK_1UNIT,BEXAR,7.6 +BLUE WING 2 SOLAR,DG_ELMEN_1UNIT,BEXAR,7.3 +OCI ALAMO 2 SOLAR-ST. HEDWIG,DG_STHWG_UNIT1,BEXAR,4.4 +OCI ALAMO 3-WALZEM SOLAR,DG_WALZM_UNIT1,BEXAR,5.5 +SUNEDISON CPS3 SOMERSET 1 SOLAR,DG_SOME1_1UNIT,BEXAR,5.6 +SUNEDISON RABEL ROAD SOLAR,DG_VALL1_1UNIT,BEXAR,9.9 +SUNEDISON SOMERSET 2 SOLAR,DG_SOME2_1UNIT,BEXAR,5.0 +SUNEDISON VALLEY ROAD SOLAR,DG_VALL2_1UNIT,BEXAR,9.9 +WHITNEY SOLAR,DG_WHITNEY_SOLAR1,BOSQUE,10.0 +7V SOLAR U1,7RNCHSLR_UNIT1,FAYETTE,139.66 +7V SOLAR,7RNCHSLR_UNIT1,FAYETTE,139.66 +COMPADRE SOLAR U1,CMPD_SLR_SOLAR1,HILL,194.5 +COMPADRE SOLAR U2,CMPD_SLR_SOLAR2,HILL,211.2 +EASTBELL MILAM SOLAR II,EBELLSL2_UNIT1,MILAM,150.0 +PEREGRINE SOLAR U1,PERE_SLR_UNIT1,GOLIAD,152.2 +PEREGRINE SOLAR U2,PERE_SLR_UNIT2,GOLIAD,147.7 +PHOTON SOLAR U4,PHO_SOLAR4,WHARTON,105.7 +SIGNAL SOLAR,SIG_SLR_UNIT1,HUNT,50.0 +XE MURAT [ADLONG] SOLAR,ADL_SOLAR1,HARRIS,60.0 +JACKALOPE SOLAR U1,JKLP_SLR_PV1,SAN PATRICIO,81.38 +JACKALOPE SOLAR U2,JKLP_SLR_PV2,SAN PATRICIO,71.74 +TEXAS BLUEBONNET SOLAR,BONETSLR_UNIT1,MCLENNAN,9.75 diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py new file mode 100644 index 00000000..97bcca52 --- /dev/null +++ b/data/generate_herbie_forecasts.py @@ -0,0 +1,164 @@ +import pandas as pd +#from pvlib.forecast import HRRR +from herbie import Herbie + +from herbie.toolbox import EasyMap, pc +from herbie import paint +import numpy as np +import matplotlib.pyplot as plt +import shutil + + +forecast_dir = "C:/Users/kperry/data/" +if __name__ == "__main__": + df = pd.read_csv("nodes.csv") + df = df[df['geocode'].isin(['9q9wtp', '9q6tde', '9qcbq0', '9qcf5u', '9q97v8', '9q9hq4'])] + points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] + names = list(df['county']) + # Associated date range for the forecasts + dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") + master_prediction_df = pd.DataFrame() + # Do HRR up to 18 hours first (2 hour forecasts) + for date in dates: + for time_horizon in range(1, 19, 1): + tries = 0 + while tries < 3: + try: + H = Herbie(date, + model="hrrr", + product="prs", + fxx=time_horizon + ) + H.download() + df = H.inventory() + # ":TCDC:entire atmosphere:anl": overall cloud cover + #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) + #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) + #":RH:2 m above ground:anl": relative humidity at surface + #TMP:surface:anl: surface temperature + #:PRES:surface:anl: surface pressure + #DPT:2 m above ground:anl: dew point + # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html + tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", + ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", + ":PRES:surface:" + str(time_horizon) + " hour fcst", + ":TMP:surface:" + str(time_horizon) + " hour fcst", + ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] + for tag in tags: + ds = H.xarray(tag,remove_grib=True) + # get all of the closest forecasts to the WECC node points + dsi = ds.herbie.nearest_points(points=points, + names=names) + # Build out a dataframe for the predictions + pred_df = pd.DataFrame() + pred_df['county'] = list(dsi.point.values) + pred_df['point_latitude'] = list(dsi.point_latitude.values) + pred_df['point_longitude'] = list(dsi.point_longitude.values) + pred_df['tag'] = tag + pred_df['forecast_time'] = date + pred_df['forecast_horizon_hrs'] = time_horizon + if "d2m" in dsi: + pred_df['value'] = list(dsi.d2m.values) + elif "tcc" in dsi: + pred_df['value'] = list(dsi.tcc.values) + elif "u" in dsi: + pred_df['value'] = list(dsi.u.values) + elif "v" in dsi: + pred_df['value'] = list(dsi.v.values) + elif "r2" in dsi: + pred_df['value'] = list(dsi.r2.values) + elif "sp" in dsi: + pred_df['value'] = list(dsi.sp.values) + elif "t" in dsi: + pred_df['value'] = list(dsi.t.values) + else: + break + master_prediction_df = pd.concat([master_prediction_df, + pred_df]) + master_prediction_df.to_csv("C:/Users/kperry/Documents/herbie_forecasts.csv", index=False) + # Delete all of the accumulated grib2 files so we don't run out of storage + shutil.rmtree(forecast_dir) + # if successful, break the while loop + break + except: + tries += 1 + # Longer term forecasts: GEFS model + for date in dates: + time_horizons = [*range(24,78, 6)] + for time_horizon in time_horizons: + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + H.download() + df = H.inventory() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + #"RH", + #"PRES", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + #":RH:2 m above ground:", + #":PRES:surface::", + "TMP:surface:", + "DPT:2 m above ground:"] + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + print(len(tag_df)) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + master_prediction_df = pd.concat([master_prediction_df, pred_df]) + # Convert overall cloud cover to GHI, using PVLib functionality + #HRRR.cloud_cover_to_ghi_linear(cloud_cover, ghi_clear) \ No newline at end of file diff --git a/data/merge_conus_nsrdb.py b/data/merge_conus_nsrdb.py new file mode 100644 index 00000000..345dff77 --- /dev/null +++ b/data/merge_conus_nsrdb.py @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- +""" +Pull NSRDB and CONUS data at different nodes for comparison. +""" + +import pandas as pd +from utils import geohash, nsrdb_weather, nsrdb_credentials +import requests +import io +import pvdrdb_tools +import time + +pdv = pvdrdb_tools.PVDRDBQuery() + +def pull_CONUS_data(latitude, longitude, hub_height, + year): + available_hub_heights = [10] +[*range(20,200, 20)] + # Get the closest hub height to the existing turbine + closest_hub_height = int(min(available_hub_heights, + key=lambda x:abs(x-hub_height))) + payload_attributes = ("temperature_" + str(int(closest_hub_height))+ + "m,pressure_0m,windspeed_" + + str(int(closest_hub_height))+ "m,winddirection_" + + str(int(closest_hub_height))+ "m") + email, api_key = nsrdb_credentials() + url = ( + "http://developer.nrel.gov/api/wind-toolkit/v2/"+ + "wind/wtk-bchrrr-v1-0-0-download.csv?wkt=POINT(" + + str(longitude) + " " + str(latitude) + + ")&attributes=" + payload_attributes + + "&names=" +str(year) + + "&utc=true&leap_day=true&email=" + str(email) + "&api_key=" + + str(api_key)) + x = requests.get(url) + # Process the data into CSV format + weather_data = pd.read_csv(io.StringIO(x.content.decode('utf-8'))) + weather_data.drop(columns=weather_data.columns[-1], inplace=True) + timezone = int(weather_data.columns[3]) + weather_data.columns = ['Year', 'Month', 'Day', 'Hour', + 'Minute', 'Air Temperature at hub height (°C)', + 'Surface Air Pressure (Pa)', + 'Wind Speed at hub height (m/s)', + 'Wind Direction at hub height(°)'] + weather_data['hub_height'] = hub_height + index_cutoff = weather_data[weather_data['Year'] =='Year'].index[0] + weather_data = weather_data[weather_data.index > index_cutoff] + weather_data.index = pd.to_datetime(weather_data['Year'] + "-" + + weather_data['Month'] + "-" + + weather_data['Day'] + " " + + weather_data['Hour'] + + ":" + weather_data['Minute'] + ":00") + weather_data.index = weather_data.index.tz_localize('UTC') + weather_data = weather_data[['Air Temperature at hub height (°C)', + 'Surface Air Pressure (Pa)', + 'Wind Speed at hub height (m/s)', + 'Wind Direction at hub height(°)']] + return weather_data + + +if __name__ == "__main__": + # Point towards the particular local folder that contains the data + metadata = pd.read_csv("nodes.csv") + # Loop through the metadata and generate the associated estimates + #metadata = metadata[metadata.index>=78] + for idx, row in metadata.iterrows(): + lat = row['Lat'] + long = row['Long'] + geohash_val = geohash(lat, long, precision=6) + min_measured_date = pd.to_datetime("2018-01-01") + max_measured_date = pd.to_datetime("2022-12-31") + # Pull the site's associated NSRDB data + master_weather_df = pd.DataFrame() + for year in range(min_measured_date.year, max_measured_date.year): + for try_time in range(0,3): + try: + df = nsrdb_weather(geohash_val, + year, + interval=30, + attributes={'Temperature': 'temp_air', + 'DHI': 'dhi', + 'DNI': 'dni', + 'GHI': 'ghi', + 'Wind Speed': 'wind_speed'}) + master_weather_df = pd.concat([master_weather_df, df]) + except: + pass + # Pull the CONUS data for the same associated period for direct comparison + master_conus_df = pd.DataFrame() + for year in range(min_measured_date.year, max_measured_date.year): + tries = 0 + while tries < 3: + try: + conus_df = pull_CONUS_data(lat, long, 80, year) + master_conus_df = pd.concat([master_conus_df, conus_df]) + time.sleep(1) + break + except: + tries += 1 + time.sleep(1) + # Merge the data sets together + df_merge = pd.merge(master_weather_df, master_conus_df, + left_index=True, right_index=True) + # Write to S3 + df_merge.to_csv('s3://pvdrdb-transfer/REGROW/nsrdb_conus_data/' + + str(row['geocode']) + '.csv', + storage_options={"key": pdv.aws['key'], + "secret": pdv.aws['secret']}) \ No newline at end of file diff --git a/data/run_pvdrdb_sites_pvwatts.py b/data/run_pvdrdb_sites_pvwatts.py new file mode 100644 index 00000000..429a64ce --- /dev/null +++ b/data/run_pvdrdb_sites_pvwatts.py @@ -0,0 +1,155 @@ +from pvlib.modelchain import ModelChain +from pvlib.pvsystem import PVSystem +from pvlib.location import Location +import pandas as pd +import math +import requests +import json +import os +import pvlib +from pvlib.temperature import TEMPERATURE_MODEL_PARAMETERS +from matplotlib import pyplot as plt +from utils import geohash, nsrdb_weather +import glob +import pvdrdb_tools + +pdv = pvdrdb_tools.PVDRDBQuery() + +def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, + solar_zenith, solar_azimuth, dni, dhi, ghi, dni_extra, + relative_airmass, temperature, wind_speed, + temperature_model_parameters, + temperature_coefficient, tracking): + """ + Run the PVWatts model using NSRDB data across the time period as inputs. + """ + if tracking: + tracker_angles = pvlib.tracking.singleaxis(solar_zenith, solar_azimuth, + axis_tilt=tilt, axis_azimuth=azimuth, + backtrack=True, gcr=0.4, max_angle=60) + surface_tilt = tracker_angles['surface_tilt'] + surface_azimuth = tracker_angles['surface_azimuth'] + else: + surface_tilt = tilt + surface_azimuth = azimuth + + poa = pvlib.irradiance.get_total_irradiance( + surface_tilt, surface_azimuth, + solar_zenith, + solar_azimuth, + dni, ghi, dhi, + dni_extra=dni_extra, + airmass=relative_airmass, + albedo=0.2, + model='perez' + ) + + aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth) + # Run IAM model + iam = pvlib.iam.physical(aoi, n=1.5) + # Apply IAM to direct POA component only + poa_transmitted = poa['poa_direct'] * iam + poa['poa_diffuse'] + temp_cell = pvlib.temperature.sapm_cell( + poa['poa_global'], + temperature, + wind_speed, + **temperature_model_parameters + ) + pdc = pvlib.pvsystem.pvwatts_dc( + poa_transmitted, + temp_cell, + dc_capacity, + temperature_coefficient + ) + return pdc + + +if __name__ == "__main__": + # Point towards the particular local folder that contains the data + data_path = "C:/Users/kperry/Documents/extreme-weather-ca-heatwave/pvwatts_pvdrdb_systems" + time_series_path = "C:/Users/kperry/Documents/extreme-weather-ca-heatwave" + metadata = pd.read_csv(os.path.join(time_series_path, + "all_states_heatwave_target_sites.csv")) + already_run = glob.glob(data_path +"/*.csv") + already_run = [os.path.basename(x) for x in already_run] + # Loop through the metadata and generate the associated estimates + for idx, row in metadata.iterrows(): + lat = row['latitude'] + long = row['longitude'] + name = row['name'] + # Get the geohash associated with the site + system_identifier = str(row['system_id']) + if system_identifier + ".csv" in already_run: + print("already run!!") + continue + geohash_val = geohash(lat, long, precision=6) + # convert to KW + power = row['power'] + tilt = row['tilt'] + azimuth = row['azimuth'] + if row['tracking']: + tracking = False + else: + tracking = True + backtracking = False + # Default tilt 0 for single-axis tracking if missing, 20 for fixed-tilt + if str(tilt) == "nan": + if tracking: + tilt = 0 + else: + tilt = 20 + min_measured_date = pd.to_datetime(row['min_measured_date']) + max_measured_date = pd.to_datetime(row['max_measured_date']) + print(min_measured_date, max_measured_date) + # Pull the site's associated NSRDB data + master_weather_df = pd.DataFrame() + for year in range(min_measured_date.year, max_measured_date.year): + for try_time in range(0,3): + try: + df = nsrdb_weather(geohash_val, + year, + interval=30, + attributes={'Temperature': 'temp_air', + 'DHI': 'dhi', + 'DNI': 'dni', + 'GHI': 'ghi', + 'Wind Speed': 'wind_speed'}) + master_weather_df = pd.concat([master_weather_df, df]) + break + except: + pass + # Build out the PVWatts model + solpos = pvlib.solarposition.get_solarposition(master_weather_df.index, + lat, long) + dni_extra = pvlib.irradiance.get_extra_radiation(master_weather_df.index) + relative_airmass = pvlib.atmosphere.get_relative_airmass(solpos.zenith) + temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass'] + pdc = run_pvwatts_model(tilt=tilt, + azimuth=azimuth, + dc_capacity=power, + dc_inverter_limit=power * 1.5, + solar_zenith=solpos.zenith, + solar_azimuth=solpos.azimuth, + dni=master_weather_df['DNI'], + dhi=master_weather_df['DHI'], + ghi=master_weather_df['GHI'], + dni_extra=dni_extra, + relative_airmass=relative_airmass, + temperature=master_weather_df['Temperature'], + wind_speed=master_weather_df['Wind Speed'], + temperature_model_parameters=temp_params, + temperature_coefficient=-0.0047, + tracking=tracking) + # Plot PDC against real + pdc.plot() + # Plot real + plt.show() + plt.close() + pdc.name = "output_kW" + # Write the results to the associated S3 bucket. + pdc.to_csv('s3://pvdrdb-transfer/REGROW/pvwatts_pvdrdb_systems/' + + str(system_identifier) + '.csv', + storage_options={"key": pdv.aws['key'], + "secret": pdv.aws['secret']}) + \ No newline at end of file From 73beb61642b37dba32741332a5ea8c6ec240db7d Mon Sep 17 00:00:00 2001 From: Perry Date: Tue, 26 Aug 2025 09:41:53 -0600 Subject: [PATCH 02/17] dask integration for herbie forecasts, currently testing --- data/generate_herbie_forecasts.py | 293 ++++++++++++++++-------------- 1 file changed, 152 insertions(+), 141 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 97bcca52..5cab3d36 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -7,6 +7,145 @@ import numpy as np import matplotlib.pyplot as plt import shutil +from dask import delayed +import os + +@delayed +def pull_herbie_hrr_data(date, time_horizon): + """ + Function for pulling Herbie data, which we will be parallelizing via Dask. + """ + H = Herbie(date, + model="hrrr", + product="prs", + fxx=time_horizon + ) + H.download() + df = H.inventory() + # ":TCDC:entire atmosphere:anl": overall cloud cover + #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) + #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) + #":RH:2 m above ground:anl": relative humidity at surface + #TMP:surface:anl: surface temperature + #:PRES:surface:anl: surface pressure + #DPT:2 m above ground:anl: dew point + # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html + tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", + ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", + ":PRES:surface:" + str(time_horizon) + " hour fcst", + ":TMP:surface:" + str(time_horizon) + " hour fcst", + ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] + for tag in tags: + ds = H.xarray(tag,remove_grib=True) + # get all of the closest forecasts to the WECC node points + dsi = ds.herbie.nearest_points(points=points, + names=names) + # Build out a dataframe for the predictions + pred_df = pd.DataFrame() + pred_df['county'] = list(dsi.point.values) + pred_df['point_latitude'] = list(dsi.point_latitude.values) + pred_df['point_longitude'] = list(dsi.point_longitude.values) + pred_df['tag'] = tag + pred_df['forecast_time'] = date + pred_df['forecast_horizon_hrs'] = time_horizon + if "d2m" in dsi: + pred_df['value'] = list(dsi.d2m.values) + elif "tcc" in dsi: + pred_df['value'] = list(dsi.tcc.values) + elif "u" in dsi: + pred_df['value'] = list(dsi.u.values) + elif "v" in dsi: + pred_df['value'] = list(dsi.v.values) + elif "r2" in dsi: + pred_df['value'] = list(dsi.r2.values) + elif "sp" in dsi: + pred_df['value'] = list(dsi.sp.values) + elif "t" in dsi: + pred_df['value'] = list(dsi.t.values) + return pred_df + +@delayed +def pull_herbie_gefs_data(data, time_horizon): + """ + Similar function for Herbie GEFS data. + """ + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + H.download() + df = H.inventory() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + #"RH", + #"PRES", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + #":RH:2 m above ground:", + #":PRES:surface::", + "TMP:surface:", + "DPT:2 m above ground:"] + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + print(len(tag_df)) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + return pred_df + + + forecast_dir = "C:/Users/kperry/data/" @@ -21,144 +160,16 @@ # Do HRR up to 18 hours first (2 hour forecasts) for date in dates: for time_horizon in range(1, 19, 1): - tries = 0 - while tries < 3: - try: - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - H.download() - df = H.inventory() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - else: - break - master_prediction_df = pd.concat([master_prediction_df, - pred_df]) - master_prediction_df.to_csv("C:/Users/kperry/Documents/herbie_forecasts.csv", index=False) - # Delete all of the accumulated grib2 files so we don't run out of storage - shutil.rmtree(forecast_dir) - # if successful, break the while loop - break - except: - tries += 1 - # Longer term forecasts: GEFS model - for date in dates: - time_horizons = [*range(24,78, 6)] - for time_horizon in time_horizons: - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - H.download() - df = H.inventory() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - master_prediction_df = pd.concat([master_prediction_df, pred_df]) - # Convert overall cloud cover to GHI, using PVLib functionality - #HRRR.cloud_cover_to_ghi_linear(cloud_cover, ghi_clear) \ No newline at end of file + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon) + hrrr_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" + ), index=False) + # Delete all of the accumulated grib2 files so we don't run out of storage + shutil.rmtree(forecast_dir) + gefs_time_horizons = [*range(24,78, 6)] + for time_horizon in gefs_time_horizons: + gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) + gefs_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" + ), index=False) + shutil.rmtree(forecast_dir) \ No newline at end of file From e1d0ae28f6a6796d04cd6d4bffa86e70adb93adc Mon Sep 17 00:00:00 2001 From: Perry Date: Tue, 26 Aug 2025 09:47:59 -0600 Subject: [PATCH 03/17] forgot compute() call, still needs optimization --- data/generate_herbie_forecasts.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 5cab3d36..9d61b900 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -21,7 +21,6 @@ def pull_herbie_hrr_data(date, time_horizon): fxx=time_horizon ) H.download() - df = H.inventory() # ":TCDC:entire atmosphere:anl": overall cloud cover #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) @@ -78,7 +77,6 @@ def pull_herbie_gefs_data(data, time_horizon): member="p01", ) H.download() - df = H.inventory() tags = ["UGRD:80 m", "VGRD:80 m", "TCDC", @@ -146,8 +144,6 @@ def pull_herbie_gefs_data(data, time_horizon): - - forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": df = pd.read_csv("nodes.csv") @@ -160,16 +156,17 @@ def pull_herbie_gefs_data(data, time_horizon): # Do HRR up to 18 hours first (2 hour forecasts) for date in dates: for time_horizon in range(1, 19, 1): - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon) + print(time_horizon) + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon).compute() hrrr_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" ), index=False) # Delete all of the accumulated grib2 files so we don't run out of storage - shutil.rmtree(forecast_dir) + #shutil.rmtree(forecast_dir) gefs_time_horizons = [*range(24,78, 6)] for time_horizon in gefs_time_horizons: - gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) + gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon).compute() gefs_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" ), index=False) - shutil.rmtree(forecast_dir) \ No newline at end of file + #shutil.rmtree(forecast_dir) \ No newline at end of file From 665c186a93ae4cb380fdcc8487246b4008d08419 Mon Sep 17 00:00:00 2001 From: Perry Date: Tue, 26 Aug 2025 12:11:30 -0600 Subject: [PATCH 04/17] more refactoring to get things to run faster --- data/generate_herbie_forecasts.py | 34 +++++++++++++++++++------------ 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 9d61b900..23b9f4c7 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -9,6 +9,7 @@ import shutil from dask import delayed import os +import dask @delayed def pull_herbie_hrr_data(date, time_horizon): @@ -20,7 +21,7 @@ def pull_herbie_hrr_data(date, time_horizon): product="prs", fxx=time_horizon ) - H.download() + file = H.download() # ":TCDC:entire atmosphere:anl": overall cloud cover #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) @@ -63,6 +64,11 @@ def pull_herbie_hrr_data(date, time_horizon): pred_df['value'] = list(dsi.sp.values) elif "t" in dsi: pred_df['value'] = list(dsi.t.values) + pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), + index=False) + # Delete the file in question (to save storage space) + os.remove(file) return pred_df @delayed @@ -76,7 +82,7 @@ def pull_herbie_gefs_data(data, time_horizon): product="atmos.5b", member="p01", ) - H.download() + file = H.download() tags = ["UGRD:80 m", "VGRD:80 m", "TCDC", @@ -140,6 +146,11 @@ def pull_herbie_gefs_data(data, time_horizon): pred_df['time_horizon_hrs'] = time_horizon pred_df['tag'] = tag pred_df['value'] = predictions + pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv"), + index=False) + # Delete the file in question (to save storage space) + os.remove(file) return pred_df @@ -154,19 +165,16 @@ def pull_herbie_gefs_data(data, time_horizon): dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") master_prediction_df = pd.DataFrame() # Do HRR up to 18 hours first (2 hour forecasts) + delayed_results = [] for date in dates: for time_horizon in range(1, 19, 1): print(time_horizon) - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon).compute() - hrrr_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", - date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" - ), index=False) + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon) + delayed_results.append(hrrr_pred_df) + results = dask.compute(*delayed_results) # Delete all of the accumulated grib2 files so we don't run out of storage #shutil.rmtree(forecast_dir) - gefs_time_horizons = [*range(24,78, 6)] - for time_horizon in gefs_time_horizons: - gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon).compute() - gefs_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", - date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv" - ), index=False) - #shutil.rmtree(forecast_dir) \ No newline at end of file + # gefs_time_horizons = [*range(24,78, 6)] + # for time_horizon in gefs_time_horizons: + # gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) + # #shutil.rmtree(forecast_dir) \ No newline at end of file From 59d8cd6bf028ff6979a05d5be6fe1b220eb89f3b Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 10:02:03 -0600 Subject: [PATCH 05/17] prototype working, moving to hpc --- data/generate_herbie_forecasts.py | 159 ++++++++++++++++++------------ 1 file changed, 97 insertions(+), 62 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 23b9f4c7..e96d9fd5 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -10,67 +10,89 @@ from dask import delayed import os import dask +import logging +import time +from dask.distributed import Client, wait, as_completed + +failed_forecast_runs = list() @delayed def pull_herbie_hrr_data(date, time_horizon): """ Function for pulling Herbie data, which we will be parallelizing via Dask. """ - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), - index=False) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df - + for i in range(20): + try: + logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") + H = Herbie(date, + model="hrrr", + product="prs", + fxx=time_horizon + ) + file = H.download() + # ":TCDC:entire atmosphere:anl": overall cloud cover + #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) + #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) + #":RH:2 m above ground:anl": relative humidity at surface + #TMP:surface:anl: surface temperature + #:PRES:surface:anl: surface pressure + #DPT:2 m above ground:anl: dew point + # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html + tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", + ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", + ":PRES:surface:" + str(time_horizon) + " hour fcst", + ":TMP:surface:" + str(time_horizon) + " hour fcst", + ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] + master_pred_list = list() + for tag in tags: + ds = H.xarray(tag,remove_grib=True) + # get all of the closest forecasts to the WECC node points + dsi = ds.herbie.nearest_points(points=points, + names=names) + # Build out a dataframe for the predictions + pred_df = pd.DataFrame() + pred_df['county'] = list(dsi.point.values) + pred_df['point_latitude'] = list(dsi.point_latitude.values) + pred_df['point_longitude'] = list(dsi.point_longitude.values) + pred_df['tag'] = tag + pred_df['forecast_time'] = date + pred_df['forecast_horizon_hrs'] = time_horizon + if "d2m" in dsi: + pred_df['value'] = list(dsi.d2m.values) + elif "tcc" in dsi: + pred_df['value'] = list(dsi.tcc.values) + elif "u" in dsi: + pred_df['value'] = list(dsi.u.values) + elif "v" in dsi: + pred_df['value'] = list(dsi.v.values) + elif "r2" in dsi: + pred_df['value'] = list(dsi.r2.values) + elif "sp" in dsi: + pred_df['value'] = list(dsi.sp.values) + elif "t" in dsi: + pred_df['value'] = list(dsi.t.values) + master_pred_list.append(pred_df) + master_pred_df = pd.concat(master_pred_list) + master_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), + index=False) + # Delete the file in question (to save storage space) + os.remove(file) + logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") + return master_pred_df + except Exception as e: + print(e) + logger.info(e) + time.sleep(10 * (i + 1)) # backoff + logger.info("Download failed for {date} {time_horizon} hr time horizon...") + failed_forecast_runs.append([date, time_horizon]) + with open("failed_runs.txt", 'w') as file: + for item in failed_forecast_runs: + file.write(str(item) + '\n') + return + @delayed def pull_herbie_gefs_data(data, time_horizon): """ @@ -97,6 +119,7 @@ def pull_herbie_gefs_data(data, time_horizon): #":PRES:surface::", "TMP:surface:", "DPT:2 m above ground:"] + master_pred_list = list() for tag in tags: tag_df=H.inventory(tag) tag_df = tag_df.reset_index(drop=True) @@ -164,17 +187,29 @@ def pull_herbie_gefs_data(data, time_horizon): # Associated date range for the forecasts dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") master_prediction_df = pd.DataFrame() + # Create a logger + logger = logging.getLogger(__name__) + logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) + # Create a console handler and set its level + ch = logging.StreamHandler() + ch.setLevel(logging.INFO) + # Create a formatter and add it to the handler + formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') + ch.setFormatter(formatter) + # Add the handler to the logger + logger.addHandler(ch) # Do HRR up to 18 hours first (2 hour forecasts) delayed_results = [] for date in dates: + print(date) for time_horizon in range(1, 19, 1): print(time_horizon) hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon) delayed_results.append(hrrr_pred_df) - results = dask.compute(*delayed_results) - # Delete all of the accumulated grib2 files so we don't run out of storage - #shutil.rmtree(forecast_dir) - # gefs_time_horizons = [*range(24,78, 6)] - # for time_horizon in gefs_time_horizons: - # gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) - # #shutil.rmtree(forecast_dir) \ No newline at end of file + results = dask.compute(*delayed_results, num_workers=2) + # Delete all of the accumulated grib2 files so we don't run out of storage + #shutil.rmtree(forecast_dir) + # gefs_time_horizons = [*range(24,78, 6)] + # for time_horizon in gefs_time_horizons: + # gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) + # #shutil.rmtree(forecast_dir) \ No newline at end of file From d5131817527cbb25ebc5104ff8a99e2471727411 Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 10:02:20 -0600 Subject: [PATCH 06/17] forgot to save --- data/generate_herbie_forecasts.py | 1 + 1 file changed, 1 insertion(+) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index e96d9fd5..29b47052 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -13,6 +13,7 @@ import logging import time from dask.distributed import Client, wait, as_completed +import pvdrdb_tools failed_forecast_runs = list() From eb6b1016ea963c5cc01801da7ae774ccbfd9f44e Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 11:56:20 -0600 Subject: [PATCH 07/17] added the logic that fully integrates with S3 and stops s3 duplications --- data/generate_herbie_forecasts.py | 47 ++++++++++++++++++++++--------- 1 file changed, 33 insertions(+), 14 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 29b47052..d9685a4d 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -14,15 +14,16 @@ import time from dask.distributed import Client, wait, as_completed import pvdrdb_tools +import boto3 failed_forecast_runs = list() @delayed -def pull_herbie_hrr_data(date, time_horizon): +def pull_herbie_hrr_data(date, time_horizon, aws_profile): """ Function for pulling Herbie data, which we will be parallelizing via Dask. """ - for i in range(20): + for i in range(3): try: logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") H = Herbie(date, @@ -76,9 +77,10 @@ def pull_herbie_hrr_data(date, time_horizon): pred_df['value'] = list(dsi.t.values) master_pred_list.append(pred_df) master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", + master_pred_df.to_csv(os.path.join('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw', date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), - index=False) + index=False, + storage_options={"profile": aws_profile}) # Delete the file in question (to save storage space) os.remove(file) logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") @@ -86,7 +88,7 @@ def pull_herbie_hrr_data(date, time_horizon): except Exception as e: print(e) logger.info(e) - time.sleep(10 * (i + 1)) # backoff + time.sleep(5) # backoff logger.info("Download failed for {date} {time_horizon} hr time horizon...") failed_forecast_runs.append([date, time_horizon]) with open("failed_runs.txt", 'w') as file: @@ -95,7 +97,7 @@ def pull_herbie_hrr_data(date, time_horizon): return @delayed -def pull_herbie_gefs_data(data, time_horizon): +def pull_herbie_gefs_data(data, time_horizon, aws_profile): """ Similar function for Herbie GEFS data. """ @@ -170,9 +172,10 @@ def pull_herbie_gefs_data(data, time_horizon): pred_df['time_horizon_hrs'] = time_horizon pred_df['tag'] = tag pred_df['value'] = predictions - pred_df.to_csv(os.path.join("C:/Users/kperry/Documents/herbie_forecasts", - date.strftime("%Y-%m-%d") + "_" + str(time_horizon) + "hr.csv"), - index=False) + pred_df.to_csv(os.path.join('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw', + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), + index=False, + storage_options={"profile": aws_profile}) # Delete the file in question (to save storage space) os.remove(file) return pred_df @@ -181,8 +184,25 @@ def pull_herbie_gefs_data(data, time_horizon): forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": + # Connect to the db and get the associated AWS creds + pvr = pvdrdb_tools.PVDRDBQuery() + pvr.connectToDB() + # Connect to S3 and get all of the files that have already been inserted. + # we want to omit these files from new runs, and only run new cases + s3_client = boto3.client('s3', + aws_access_key_id=pvr.aws['key'], + aws_secret_access_key=pvr.aws['secret']) + paginator = s3_client.get_paginator('list_objects_v2') + pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") + file_keys = list() + for page in pages: + if 'Contents' in page: + for obj in page['Contents']: + if obj['Key'] != "REGROW/herbie_forecasts/raw/": + file_keys.append(obj['Key']) + existing_files = [os.path.basename(x) for x in file_keys] + # Read in the nodes we want to forecast on df = pd.read_csv("nodes.csv") - df = df[df['geocode'].isin(['9q9wtp', '9q6tde', '9qcbq0', '9qcf5u', '9q97v8', '9q9hq4'])] points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] names = list(df['county']) # Associated date range for the forecasts @@ -202,11 +222,10 @@ def pull_herbie_gefs_data(data, time_horizon): # Do HRR up to 18 hours first (2 hour forecasts) delayed_results = [] for date in dates: - print(date) for time_horizon in range(1, 19, 1): - print(time_horizon) - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon) - delayed_results.append(hrrr_pred_df) + if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) + delayed_results.append(hrrr_pred_df) results = dask.compute(*delayed_results, num_workers=2) # Delete all of the accumulated grib2 files so we don't run out of storage #shutil.rmtree(forecast_dir) From 0136ac97938e0afe1d78100074bced1d358dbb91 Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 12:02:19 -0600 Subject: [PATCH 08/17] debugged insertions --- data/generate_herbie_forecasts.py | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index d9685a4d..15c2adc8 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -16,7 +16,6 @@ import pvdrdb_tools import boto3 -failed_forecast_runs = list() @delayed def pull_herbie_hrr_data(date, time_horizon, aws_profile): @@ -77,10 +76,10 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): pred_df['value'] = list(dsi.t.values) master_pred_list.append(pred_df) master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv(os.path.join('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw', - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), + master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", index=False, - storage_options={"profile": aws_profile}) + storage_options=aws_profile) # Delete the file in question (to save storage space) os.remove(file) logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") @@ -90,10 +89,6 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): logger.info(e) time.sleep(5) # backoff logger.info("Download failed for {date} {time_horizon} hr time horizon...") - failed_forecast_runs.append([date, time_horizon]) - with open("failed_runs.txt", 'w') as file: - for item in failed_forecast_runs: - file.write(str(item) + '\n') return @delayed @@ -172,10 +167,10 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): pred_df['time_horizon_hrs'] = time_horizon pred_df['tag'] = tag pred_df['value'] = predictions - pred_df.to_csv(os.path.join('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw', - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv"), + pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", index=False, - storage_options={"profile": aws_profile}) + storage_options=aws_profile) # Delete the file in question (to save storage space) os.remove(file) return pred_df From ab56cc281b1429207d5d22ecb54efd658a78ddb2 Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 12:09:27 -0600 Subject: [PATCH 09/17] more updates to make code run without issues --- data/generate_herbie_forecasts.py | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 15c2adc8..3b1c7913 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -80,9 +80,8 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", index=False, storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") + os.remove(file) return master_pred_df except Exception as e: print(e) @@ -222,9 +221,3 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) delayed_results.append(hrrr_pred_df) results = dask.compute(*delayed_results, num_workers=2) - # Delete all of the accumulated grib2 files so we don't run out of storage - #shutil.rmtree(forecast_dir) - # gefs_time_horizons = [*range(24,78, 6)] - # for time_horizon in gefs_time_horizons: - # gefs_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon) - # #shutil.rmtree(forecast_dir) \ No newline at end of file From 6551d1e743e2ba9196b332c3279e2b22c80fc46b Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 12:28:08 -0600 Subject: [PATCH 10/17] added slurm version of herbie --- data/failed_runs.txt | 1 + data/generate_herbie_forecasts.py | 23 ++- data/generate_herbie_forecasts_local.py | 236 +++++++++++++++++++++++ data/generate_herbie_forecasts_slurm.py | 238 ++++++++++++++++++++++++ 4 files changed, 494 insertions(+), 4 deletions(-) create mode 100644 data/failed_runs.txt create mode 100644 data/generate_herbie_forecasts_local.py create mode 100644 data/generate_herbie_forecasts_slurm.py diff --git a/data/failed_runs.txt b/data/failed_runs.txt new file mode 100644 index 00000000..bef80835 --- /dev/null +++ b/data/failed_runs.txt @@ -0,0 +1 @@ +[Timestamp('2021-01-26 00:00:00'), 3] diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 3b1c7913..98672e19 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -15,6 +15,10 @@ from dask.distributed import Client, wait, as_completed import pvdrdb_tools import boto3 +from dask_jobqueue import SLURMCluster +import socket +from dask.distributed import Client +from collections import Counter @delayed @@ -178,6 +182,15 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": + # Declare SLURM Cluster + cluster = SLURMCluster( + cores=18, + memory='24GB', + account='pvfleets24', + walltime='00:30:00', + processes=17, + queue='shared' + ) # Connect to the db and get the associated AWS creds pvr = pvdrdb_tools.PVDRDBQuery() pvr.connectToDB() @@ -213,11 +226,13 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): ch.setFormatter(formatter) # Add the handler to the logger logger.addHandler(ch) - # Do HRR up to 18 hours first (2 hour forecasts) - delayed_results = [] + client = Client(cluster) + result = [] + cluster.scale(jobs=4) for date in dates: for time_horizon in range(1, 19, 1): if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) + result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) delayed_results.append(hrrr_pred_df) - results = dask.compute(*delayed_results, num_workers=2) + print(Counter(result)) + print(cluster.job_script()) \ No newline at end of file diff --git a/data/generate_herbie_forecasts_local.py b/data/generate_herbie_forecasts_local.py new file mode 100644 index 00000000..defa46d4 --- /dev/null +++ b/data/generate_herbie_forecasts_local.py @@ -0,0 +1,236 @@ +import pandas as pd +#from pvlib.forecast import HRRR +from herbie import Herbie + +from herbie.toolbox import EasyMap, pc +from herbie import paint +import numpy as np +import matplotlib.pyplot as plt +import shutil +from dask import delayed +import os +import dask +import logging +import time +from dask.distributed import Client, wait, as_completed +import pvdrdb_tools +import boto3 +from dask_jobqueue import SLURMCluster +import socket +from dask.distributed import Client +from collections import Counter + + +@delayed +def pull_herbie_hrr_data(date, time_horizon, aws_profile): + """ + Function for pulling Herbie data, which we will be parallelizing via Dask. + """ + for i in range(3): + try: + logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") + H = Herbie(date, + model="hrrr", + product="prs", + fxx=time_horizon + ) + file = H.download() + # ":TCDC:entire atmosphere:anl": overall cloud cover + #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) + #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) + #":RH:2 m above ground:anl": relative humidity at surface + #TMP:surface:anl: surface temperature + #:PRES:surface:anl: surface pressure + #DPT:2 m above ground:anl: dew point + # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html + tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", + ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", + ":PRES:surface:" + str(time_horizon) + " hour fcst", + ":TMP:surface:" + str(time_horizon) + " hour fcst", + ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] + master_pred_list = list() + for tag in tags: + ds = H.xarray(tag,remove_grib=True) + # get all of the closest forecasts to the WECC node points + dsi = ds.herbie.nearest_points(points=points, + names=names) + # Build out a dataframe for the predictions + pred_df = pd.DataFrame() + pred_df['county'] = list(dsi.point.values) + pred_df['point_latitude'] = list(dsi.point_latitude.values) + pred_df['point_longitude'] = list(dsi.point_longitude.values) + pred_df['tag'] = tag + pred_df['forecast_time'] = date + pred_df['forecast_horizon_hrs'] = time_horizon + if "d2m" in dsi: + pred_df['value'] = list(dsi.d2m.values) + elif "tcc" in dsi: + pred_df['value'] = list(dsi.tcc.values) + elif "u" in dsi: + pred_df['value'] = list(dsi.u.values) + elif "v" in dsi: + pred_df['value'] = list(dsi.v.values) + elif "r2" in dsi: + pred_df['value'] = list(dsi.r2.values) + elif "sp" in dsi: + pred_df['value'] = list(dsi.sp.values) + elif "t" in dsi: + pred_df['value'] = list(dsi.t.values) + master_pred_list.append(pred_df) + master_pred_df = pd.concat(master_pred_list) + master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") + os.remove(file) + return master_pred_df + except Exception as e: + print(e) + logger.info(e) + time.sleep(5) # backoff + logger.info("Download failed for {date} {time_horizon} hr time horizon...") + return + +@delayed +def pull_herbie_gefs_data(data, time_horizon, aws_profile): + """ + Similar function for Herbie GEFS data. + """ + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + file = H.download() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + #"RH", + #"PRES", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + #":RH:2 m above ground:", + #":PRES:surface::", + "TMP:surface:", + "DPT:2 m above ground:"] + master_pred_list = list() + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + print(len(tag_df)) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + # Delete the file in question (to save storage space) + os.remove(file) + return pred_df + + + +forecast_dir = "C:/Users/kperry/data/" +if __name__ == "__main__": + # Declare SLURM Cluster + cluster = SLURMCluster( + cores=18, + memory='24GB', + account='pvfleets24', + walltime='00:30:00', + processes=17, + queue='shared' + ) + # Connect to the db and get the associated AWS creds + pvr = pvdrdb_tools.PVDRDBQuery() + pvr.connectToDB() + # Connect to S3 and get all of the files that have already been inserted. + # we want to omit these files from new runs, and only run new cases + s3_client = boto3.client('s3', + aws_access_key_id=pvr.aws['key'], + aws_secret_access_key=pvr.aws['secret']) + paginator = s3_client.get_paginator('list_objects_v2') + pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") + file_keys = list() + for page in pages: + if 'Contents' in page: + for obj in page['Contents']: + if obj['Key'] != "REGROW/herbie_forecasts/raw/": + file_keys.append(obj['Key']) + existing_files = [os.path.basename(x) for x in file_keys] + # Read in the nodes we want to forecast on + df = pd.read_csv("nodes.csv") + points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] + names = list(df['county']) + # Associated date range for the forecasts + dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") + master_prediction_df = pd.DataFrame() + # Create a logger + logger = logging.getLogger(__name__) + logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) + # Create a console handler and set its level + ch = logging.StreamHandler() + ch.setLevel(logging.INFO) + # Create a formatter and add it to the handler + formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') + ch.setFormatter(formatter) + # Add the handler to the logger + logger.addHandler(ch) + # Do HRR up to 18 hours first (2 hour forecasts) + delayed_results = [] + for date in dates: + for time_horizon in range(1, 19, 1): + if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) + delayed_results.append(hrrr_pred_df) + results = dask.compute(*delayed_results, num_workers=2) diff --git a/data/generate_herbie_forecasts_slurm.py b/data/generate_herbie_forecasts_slurm.py new file mode 100644 index 00000000..fc661be8 --- /dev/null +++ b/data/generate_herbie_forecasts_slurm.py @@ -0,0 +1,238 @@ +import pandas as pd +#from pvlib.forecast import HRRR +from herbie import Herbie + +from herbie.toolbox import EasyMap, pc +from herbie import paint +import numpy as np +import matplotlib.pyplot as plt +import shutil +from dask import delayed +import os +import dask +import logging +import time +from dask.distributed import Client, wait, as_completed +import pvdrdb_tools +import boto3 +from dask_jobqueue import SLURMCluster +import socket +from dask.distributed import Client +from collections import Counter + + +@delayed +def pull_herbie_hrr_data(date, time_horizon, aws_profile): + """ + Function for pulling Herbie data, which we will be parallelizing via Dask. + """ + for i in range(3): + try: + logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") + H = Herbie(date, + model="hrrr", + product="prs", + fxx=time_horizon + ) + file = H.download() + # ":TCDC:entire atmosphere:anl": overall cloud cover + #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) + #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) + #":RH:2 m above ground:anl": relative humidity at surface + #TMP:surface:anl: surface temperature + #:PRES:surface:anl: surface pressure + #DPT:2 m above ground:anl: dew point + # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html + tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", + ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", + ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", + ":PRES:surface:" + str(time_horizon) + " hour fcst", + ":TMP:surface:" + str(time_horizon) + " hour fcst", + ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] + master_pred_list = list() + for tag in tags: + ds = H.xarray(tag,remove_grib=True) + # get all of the closest forecasts to the WECC node points + dsi = ds.herbie.nearest_points(points=points, + names=names) + # Build out a dataframe for the predictions + pred_df = pd.DataFrame() + pred_df['county'] = list(dsi.point.values) + pred_df['point_latitude'] = list(dsi.point_latitude.values) + pred_df['point_longitude'] = list(dsi.point_longitude.values) + pred_df['tag'] = tag + pred_df['forecast_time'] = date + pred_df['forecast_horizon_hrs'] = time_horizon + if "d2m" in dsi: + pred_df['value'] = list(dsi.d2m.values) + elif "tcc" in dsi: + pred_df['value'] = list(dsi.tcc.values) + elif "u" in dsi: + pred_df['value'] = list(dsi.u.values) + elif "v" in dsi: + pred_df['value'] = list(dsi.v.values) + elif "r2" in dsi: + pred_df['value'] = list(dsi.r2.values) + elif "sp" in dsi: + pred_df['value'] = list(dsi.sp.values) + elif "t" in dsi: + pred_df['value'] = list(dsi.t.values) + master_pred_list.append(pred_df) + master_pred_df = pd.concat(master_pred_list) + master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") + os.remove(file) + return master_pred_df + except Exception as e: + print(e) + logger.info(e) + time.sleep(5) # backoff + logger.info("Download failed for {date} {time_horizon} hr time horizon...") + return + +@delayed +def pull_herbie_gefs_data(data, time_horizon, aws_profile): + """ + Similar function for Herbie GEFS data. + """ + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + file = H.download() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + #"RH", + #"PRES", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + #":RH:2 m above ground:", + #":PRES:surface::", + "TMP:surface:", + "DPT:2 m above ground:"] + master_pred_list = list() + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + print(len(tag_df)) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + # Delete the file in question (to save storage space) + os.remove(file) + return pred_df + + + +forecast_dir = "C:/Users/kperry/data/" +if __name__ == "__main__": + # Declare SLURM Cluster + cluster = SLURMCluster( + cores=18, + memory='24GB', + account='pvfleets24', + walltime='00:30:00', + processes=17, + queue='shared' + ) + # Connect to the db and get the associated AWS creds + pvr = pvdrdb_tools.PVDRDBQuery() + pvr.connectToDB() + # Connect to S3 and get all of the files that have already been inserted. + # we want to omit these files from new runs, and only run new cases + s3_client = boto3.client('s3', + aws_access_key_id=pvr.aws['key'], + aws_secret_access_key=pvr.aws['secret']) + paginator = s3_client.get_paginator('list_objects_v2') + pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") + file_keys = list() + for page in pages: + if 'Contents' in page: + for obj in page['Contents']: + if obj['Key'] != "REGROW/herbie_forecasts/raw/": + file_keys.append(obj['Key']) + existing_files = [os.path.basename(x) for x in file_keys] + # Read in the nodes we want to forecast on + df = pd.read_csv("nodes.csv") + points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] + names = list(df['county']) + # Associated date range for the forecasts + dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") + master_prediction_df = pd.DataFrame() + # Create a logger + logger = logging.getLogger(__name__) + logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) + # Create a console handler and set its level + ch = logging.StreamHandler() + ch.setLevel(logging.INFO) + # Create a formatter and add it to the handler + formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') + ch.setFormatter(formatter) + # Add the handler to the logger + logger.addHandler(ch) + # Do HRR up to 18 hours first (2 hour forecasts) + client = Client(cluster) + result = [] + cluster.scale(jobs=4) + for date in dates: + for time_horizon in range(1, 19, 1): + if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) + print(Counter(result)) + print(cluster.job_script()) \ No newline at end of file From 02d16c911a84383f4c8f6e3af19ff03acd4376db Mon Sep 17 00:00:00 2001 From: Perry Date: Wed, 27 Aug 2025 13:22:50 -0600 Subject: [PATCH 11/17] update local pull file --- data/generate_herbie_forecasts_local.py | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/data/generate_herbie_forecasts_local.py b/data/generate_herbie_forecasts_local.py index defa46d4..9e171a3a 100644 --- a/data/generate_herbie_forecasts_local.py +++ b/data/generate_herbie_forecasts_local.py @@ -182,15 +182,6 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": - # Declare SLURM Cluster - cluster = SLURMCluster( - cores=18, - memory='24GB', - account='pvfleets24', - walltime='00:30:00', - processes=17, - queue='shared' - ) # Connect to the db and get the associated AWS creds pvr = pvdrdb_tools.PVDRDBQuery() pvr.connectToDB() @@ -233,4 +224,4 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) delayed_results.append(hrrr_pred_df) - results = dask.compute(*delayed_results, num_workers=2) + results = dask.compute(*delayed_results, num_workers=4) From 34cd25db9feec2eeb14db4435a694a432cacfb94 Mon Sep 17 00:00:00 2001 From: kperry Date: Mon, 24 Nov 2025 14:02:44 -0700 Subject: [PATCH 12/17] added scripts for loading and processing herbie data --- data/generate_herbie_forecasts.py | 195 +++--- data/generate_herbie_forecasts_local.py | 227 ------- data/generate_herbie_forecasts_slurm.py | 238 -------- data/process_herbie_forecasts.py | 124 ++++ data/psm3.py | 6 +- data/pvwatts_comparison.csv | 757 ++++++++++++++++++++++++ data/run_pvwatts.py | 39 +- data/utils.py | 2 +- 8 files changed, 1009 insertions(+), 579 deletions(-) delete mode 100644 data/generate_herbie_forecasts_local.py delete mode 100644 data/generate_herbie_forecasts_slurm.py create mode 100644 data/process_herbie_forecasts.py create mode 100644 data/pvwatts_comparison.csv diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 98672e19..83540061 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -95,102 +95,99 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): return @delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): +def pull_herbie_gefs_data(date, time_horizon, aws_profile): """ Similar function for Herbie GEFS data. """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df + for i in range(3): + try: + logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + file = H.download() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + "TMP:surface:", + "DPT:2 m above ground:"] + master_pred_df= pd.DataFrame() + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + if isinstance(ds, list): + ds = ds[int(index_val)] + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + master_pred_df = pd.concat([master_pred_df, pred_df]) + master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + # Delete the file in question (to save storage space) + os.remove(file) + except Exception as e: + print(e) + logger.info(e) + time.sleep(5) # backoff + logger.info("Download failed for {date} {time_horizon} hr time horizon...") + return forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": - # Declare SLURM Cluster - cluster = SLURMCluster( - cores=18, - memory='24GB', - account='pvfleets24', - walltime='00:30:00', - processes=17, - queue='shared' - ) # Connect to the db and get the associated AWS creds pvr = pvdrdb_tools.PVDRDBQuery() pvr.connectToDB() @@ -226,13 +223,21 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): ch.setFormatter(formatter) # Add the handler to the logger logger.addHandler(ch) - client = Client(cluster) - result = [] - cluster.scale(jobs=4) + # Do HRR up to 18 hours first (2 hour forecasts) + # delayed_results = [] + # for date in dates: + # for time_horizon in range(1, 19, 1): + # if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + # hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) + # delayed_results.append(hrrr_pred_df) + # results = dask.compute(*delayed_results, num_workers=4) + # Do GEFS between 24-72 hours (once every 6 hours) + listing = list() + delayed_results = [] for date in dates: - for time_horizon in range(1, 19, 1): + for time_horizon in range(24, 78, 6): if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) + listing.append([date, time_horizon]) + hrrr_pred_df = delayed(pull_herbie_gefs_data)(date, time_horizon, pvr.aws) delayed_results.append(hrrr_pred_df) - print(Counter(result)) - print(cluster.job_script()) \ No newline at end of file + results = dask.compute(*delayed_results, num_workers=1) \ No newline at end of file diff --git a/data/generate_herbie_forecasts_local.py b/data/generate_herbie_forecasts_local.py deleted file mode 100644 index 9e171a3a..00000000 --- a/data/generate_herbie_forecasts_local.py +++ /dev/null @@ -1,227 +0,0 @@ -import pandas as pd -#from pvlib.forecast import HRRR -from herbie import Herbie - -from herbie.toolbox import EasyMap, pc -from herbie import paint -import numpy as np -import matplotlib.pyplot as plt -import shutil -from dask import delayed -import os -import dask -import logging -import time -from dask.distributed import Client, wait, as_completed -import pvdrdb_tools -import boto3 -from dask_jobqueue import SLURMCluster -import socket -from dask.distributed import Client -from collections import Counter - - -@delayed -def pull_herbie_hrr_data(date, time_horizon, aws_profile): - """ - Function for pulling Herbie data, which we will be parallelizing via Dask. - """ - for i in range(3): - try: - logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - master_pred_list = list() - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - master_pred_list.append(pred_df) - master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") - os.remove(file) - return master_pred_df - except Exception as e: - print(e) - logger.info(e) - time.sleep(5) # backoff - logger.info("Download failed for {date} {time_horizon} hr time horizon...") - return - -@delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): - """ - Similar function for Herbie GEFS data. - """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df - - - -forecast_dir = "C:/Users/kperry/data/" -if __name__ == "__main__": - # Connect to the db and get the associated AWS creds - pvr = pvdrdb_tools.PVDRDBQuery() - pvr.connectToDB() - # Connect to S3 and get all of the files that have already been inserted. - # we want to omit these files from new runs, and only run new cases - s3_client = boto3.client('s3', - aws_access_key_id=pvr.aws['key'], - aws_secret_access_key=pvr.aws['secret']) - paginator = s3_client.get_paginator('list_objects_v2') - pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") - file_keys = list() - for page in pages: - if 'Contents' in page: - for obj in page['Contents']: - if obj['Key'] != "REGROW/herbie_forecasts/raw/": - file_keys.append(obj['Key']) - existing_files = [os.path.basename(x) for x in file_keys] - # Read in the nodes we want to forecast on - df = pd.read_csv("nodes.csv") - points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] - names = list(df['county']) - # Associated date range for the forecasts - dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") - master_prediction_df = pd.DataFrame() - # Create a logger - logger = logging.getLogger(__name__) - logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) - # Create a console handler and set its level - ch = logging.StreamHandler() - ch.setLevel(logging.INFO) - # Create a formatter and add it to the handler - formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') - ch.setFormatter(formatter) - # Add the handler to the logger - logger.addHandler(ch) - # Do HRR up to 18 hours first (2 hour forecasts) - delayed_results = [] - for date in dates: - for time_horizon in range(1, 19, 1): - if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) - delayed_results.append(hrrr_pred_df) - results = dask.compute(*delayed_results, num_workers=4) diff --git a/data/generate_herbie_forecasts_slurm.py b/data/generate_herbie_forecasts_slurm.py deleted file mode 100644 index fc661be8..00000000 --- a/data/generate_herbie_forecasts_slurm.py +++ /dev/null @@ -1,238 +0,0 @@ -import pandas as pd -#from pvlib.forecast import HRRR -from herbie import Herbie - -from herbie.toolbox import EasyMap, pc -from herbie import paint -import numpy as np -import matplotlib.pyplot as plt -import shutil -from dask import delayed -import os -import dask -import logging -import time -from dask.distributed import Client, wait, as_completed -import pvdrdb_tools -import boto3 -from dask_jobqueue import SLURMCluster -import socket -from dask.distributed import Client -from collections import Counter - - -@delayed -def pull_herbie_hrr_data(date, time_horizon, aws_profile): - """ - Function for pulling Herbie data, which we will be parallelizing via Dask. - """ - for i in range(3): - try: - logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - master_pred_list = list() - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - master_pred_list.append(pred_df) - master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") - os.remove(file) - return master_pred_df - except Exception as e: - print(e) - logger.info(e) - time.sleep(5) # backoff - logger.info("Download failed for {date} {time_horizon} hr time horizon...") - return - -@delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): - """ - Similar function for Herbie GEFS data. - """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df - - - -forecast_dir = "C:/Users/kperry/data/" -if __name__ == "__main__": - # Declare SLURM Cluster - cluster = SLURMCluster( - cores=18, - memory='24GB', - account='pvfleets24', - walltime='00:30:00', - processes=17, - queue='shared' - ) - # Connect to the db and get the associated AWS creds - pvr = pvdrdb_tools.PVDRDBQuery() - pvr.connectToDB() - # Connect to S3 and get all of the files that have already been inserted. - # we want to omit these files from new runs, and only run new cases - s3_client = boto3.client('s3', - aws_access_key_id=pvr.aws['key'], - aws_secret_access_key=pvr.aws['secret']) - paginator = s3_client.get_paginator('list_objects_v2') - pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") - file_keys = list() - for page in pages: - if 'Contents' in page: - for obj in page['Contents']: - if obj['Key'] != "REGROW/herbie_forecasts/raw/": - file_keys.append(obj['Key']) - existing_files = [os.path.basename(x) for x in file_keys] - # Read in the nodes we want to forecast on - df = pd.read_csv("nodes.csv") - points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] - names = list(df['county']) - # Associated date range for the forecasts - dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") - master_prediction_df = pd.DataFrame() - # Create a logger - logger = logging.getLogger(__name__) - logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) - # Create a console handler and set its level - ch = logging.StreamHandler() - ch.setLevel(logging.INFO) - # Create a formatter and add it to the handler - formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') - ch.setFormatter(formatter) - # Add the handler to the logger - logger.addHandler(ch) - # Do HRR up to 18 hours first (2 hour forecasts) - client = Client(cluster) - result = [] - cluster.scale(jobs=4) - for date in dates: - for time_horizon in range(1, 19, 1): - if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) - print(Counter(result)) - print(cluster.job_script()) \ No newline at end of file diff --git a/data/process_herbie_forecasts.py b/data/process_herbie_forecasts.py new file mode 100644 index 00000000..acd9826b --- /dev/null +++ b/data/process_herbie_forecasts.py @@ -0,0 +1,124 @@ +import boto3 +from aws_access_cred_manager import aws_keys_and_tokens +import pvdrdb_tools +import pandas as pd +import glob +import os + + +key="YOUR KEY" +secret="YOUR SECRET" +token="YOUR TOKEN" + +def geohash(latitude, longitude, precision=6): + """Encode a position given in float arguments latitude, longitude to + a geohash which will have the character count precision. + """ + from math import log10 + __base32 = '0123456789bcdefghjkmnpqrstuvwxyz' + __decodemap = { } + for i in range(len(__base32)): + __decodemap[__base32[i]] = i + del i + lat_interval, lon_interval = (-90.0, 90.0), (-180.0, 180.0) + geohash = [] + bits = [ 16, 8, 4, 2, 1 ] + bit = 0 + ch = 0 + even = True + while len(geohash) < precision: + if even: + mid = (lon_interval[0] + lon_interval[1]) / 2 + if longitude > mid: + ch |= bits[bit] + lon_interval = (mid, lon_interval[1]) + else: + lon_interval = (lon_interval[0], mid) + else: + mid = (lat_interval[0] + lat_interval[1]) / 2 + if latitude > mid: + ch |= bits[bit] + lat_interval = (mid, lat_interval[1]) + else: + lat_interval = (lat_interval[0], mid) + even = not even + if bit < 4: + bit += 1 + else: + geohash += __base32[ch] + bit = 0 + ch = 0 + return ''.join(geohash) + +already_inserted_files = [os.path.basename(x).replace('.csv', "") for x in glob.glob("C:/Users/kperry/Documents/forecast_data_pivot/*.csv")] + +s3 = boto3.client('s3', + aws_access_key_id=key, + aws_secret_access_key=secret, + aws_session_token=token) +bucket_name = "regrow" +paginator = s3.get_paginator('list_objects_v2') +pages = paginator.paginate(Bucket=bucket_name, + Prefix="Weather_data/herbie_forecasts/raw") + +key_list = list() +for page in pages: + for obj in page['Contents']: + key_list.append(obj['Key']) +dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") + +for date in dates: + date =str(date).replace(" ", "_").replace(":", "_") + date_files = [key for key in key_list if date in key] + if date in already_inserted_files: + print("already inserted, skipping...") + continue + # read all of the date files out, append together, make master file + # and then save + master_df = pd.DataFrame() + for date_file in date_files: + response = s3.get_object(Bucket=bucket_name, Key=date_file) + df = pd.read_csv(response['Body']) + if "latitude" in list(df.columns): + df = df.rename(columns={"latitude": "point_latitude", + "longitude": "point_longitude", + 'time_horizon_hrs': 'forecast_horizon_hrs'}) + master_df = pd.concat([master_df, df], axis=0, ignore_index=True) + master_df['tag_final'] = ["_".join(x.split(":")[:-1]) for x in list(master_df['tag'])] + master_df.loc[master_df['tag_final'] == "", "tag_final"] = master_df['tag'] + master_df = master_df[master_df['tag_final'] != "TCDC"] + # Tag renamer to line up GEFS with HRRR + column_rename_dict = {"DPT": "_DPT_2 m above ground", + "TCDC": "_TCDC_entire atmosphere", + "TMP": "_TMP_surface", + "UGRD": "_UGRD_80 m above ground", + "VGRD": "_VGRD_80 m above ground"} + master_df['tag_final'] = master_df['tag_final'].replace(column_rename_dict) + pivot_table_df = master_df.pivot_table(index=['forecast_time', 'forecast_horizon_hrs', + 'point_latitude', 'point_longitude'], + columns='tag_final', values='value', + aggfunc='sum') + pivot_table_df.to_csv("C:/Users/kperry/Documents/forecast_data_pivot/" + date + ".csv") + print("inserted successfully!") + +# Now loop through all of the nodes and aggregate up the forecast data +pivot_table_df = pd.read_csv("C:/Users/kperry/Documents/source/repos/regrow/data/nodes.csv") +pivot_table_df = pivot_table_df.rename(columns={"Lat": "point_latitude", + "Long": "point_longitude"}) +lat_lon_df = pivot_table_df[['point_latitude', 'point_longitude']].drop_duplicates() + +files = glob.glob("C:/Users/kperry/Documents/forecast_data_pivot/*") + +for idx, row in lat_lon_df.iterrows(): + latitude, longitude = row['point_latitude'], row['point_longitude'] + df_lat_lon_forecast = pd.DataFrame() + for file in files: + df_forecast = pd.read_csv(file) + df_forecast = df_forecast[(df_forecast['point_latitude'] == latitude) & + (df_forecast['point_longitude'] == longitude)] + df_lat_lon_forecast = pd.concat([df_lat_lon_forecast, df_forecast]) + geohash_val = geohash(latitude, longitude) + df_lat_lon_forecast.to_csv("C:/Users/kperry/Documents/forecast_aggregated/" + str(geohash_val) + "_forecast.csv", + index=False) + + \ No newline at end of file diff --git a/data/psm3.py b/data/psm3.py index 97e5f287..f9ff10a3 100644 --- a/data/psm3.py +++ b/data/psm3.py @@ -10,9 +10,9 @@ import warnings NSRDB_API_BASE = "https://developer.nrel.gov" -PSM_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/psm3-2-2-download.csv" -TMY_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/psm3-tmy-download.csv" -PSM5MIN_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/psm3-5min-download.csv" +PSM_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/nsrdb-GOES-aggregated-v4-0-0-download" +TMY_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/nsrdb-GOES-tmy-v4-0-0-download" +PSM5MIN_URL = NSRDB_API_BASE + "/api/nsrdb/v2/solar/nsrdb-GOES-conus-v4-0-0-download" ATTRIBUTES = ( 'air_temperature', 'dew_point', 'dhi', 'dni', 'ghi', 'surface_albedo', diff --git a/data/pvwatts_comparison.csv b/data/pvwatts_comparison.csv new file mode 100644 index 00000000..43c39fc4 --- /dev/null +++ b/data/pvwatts_comparison.csv @@ -0,0 +1,757 @@ +file_name,eia_id,total_eia_production_mwh,total_pvwatts_production_mwh,difference_mwh_eia_pvwatts +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Desert_Green_Solar_Farm,_LLC_33.26524_-116.327979.csv",57959,66028.01999999999,79242.33006126623,-13214.310061266238 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Genentech-Oceanside_Hybrid_33.212308_-117.301917.csv,60231,34316.049999999996,54447.919881530834,-20131.869881530838 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Granger_33.269396_-117.057731.csv,60516,37047.990000000005,36239.70443118328,808.2855688167256 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Jacumba_Solar_Farm_32.618331_-116.132302.csv,60947,216426.01000000004,222693.03356197916,-6267.02356197912 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Ramona_1_33.010432_-116.872109.csv,58909,26006.02,25025.024935710873,980.9950642891272 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Ramona_2_33.010667_-116.874251.csv,58911,45985.03,62562.577386709745,-16577.547386709746 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Ramona_Solar_Energy_33.019293_-116.860202.csv,60995,23159.860000000004,38449.44079461264,-15289.580794612633 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_SDCWA-Twin_Oaks_33.210648_-117.178261.csv,59139,6824.029999999999,11035.259968840728,-4211.229968840729 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Solar_Borrego_I_33.293521_-116.352258.csv,57455,335165.05,333990.3745752273,1174.675424772664 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Vallecitos_Water_District_33.210674_-117.176837.csv,64438,4675.030000000001,5644.695257404968,-969.6652574049676 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Valley_Center_1_33.230008_-117.003108.csv,58906,28507.03,30877.777170355534,-2370.7471703555348 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Valley_Center_2_33.233067_-117.001487.csv,58907,58105.07,61754.558544464046,-3649.488544464046 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mudw2_Valley_Center_33.249653_-117.02176.csv,60509,29165.019999999997,28290.174972326742,874.8450276732547 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Adelanto_Solar,_LLC_34.553793_-117.377244.csv",59441,281117.01,260235.86964622766,20881.140353772353 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Adelanto_Solar_II,_LLC_34.553839_-117.369657.csv",59440,87416.04000000001,91082.47312051566,-3666.4331205156486 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Adelanto_Solar_Project_34.547517_-117.440508.csv,57305,60708.05,110927.07422070407,-50219.02422070407 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Alamo_Solar_34.685814_-117.345262.csv,59469,235343.04999999996,242999.1136903124,-7656.06369031244 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Cascade_Solar_34.166356_-116.235876.csv,58590,260143.05999999997,239772.2306266295,20370.829373370478 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_CA_Institute_for_Women_33.947505_-117.639748.csv,64518,7358.030000000001,7317.6301001008915,40.39989989910919 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Colton_Solar_One,_LLC_34.094045_-117.319013.csv",59597,22683.030000000002,22186.1589381058,496.8710618942023 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Colton_Solar_Two,_LLC_34.042263_-117.361811.csv",59598,8374.019999999999,12185.828380664965,-3811.8083806649665 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Coronus_Adelanto_West_1_34.54982_-117.466688.csv,59536,11911.02,16332.762988288998,-4421.742988288997 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Coronus_Adelanto_West_2_34.548893_-117.467441.csv,59537,15019.009999999998,16332.79102642572,-1313.7810264257223 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Crafton_Hills_College_Solar_Farm_34.043323_-117.097058.csv,58170,4792.629999999999,15755.553736224354,-10962.923736224355 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Expressway_Solar_A_34.582289_-117.341622.csv,58761,24341.04,21808.053268107928,2532.9867318920733 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Expressway_Solar_B_34.58338_-117.341455.csv,58762,20935.000000000004,21808.032930566438,-873.0329305664345 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Expressway_Solar_C2_34.584613_-117.342225.csv,58763,15826.0,16355.969973173433,-529.9699731734327 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Hudson-High_Desert_Hybrid_34.625739_-117.369334.csv,64624,390203.0,522663.9657288392,-132460.96572883922 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Industry_Solar_Power_Generation_Station_1,_LLC_34.552307_-117.456763.csv",58609,20957.99,19599.02318076282,1358.9668192371828 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Lone_Valley_Solar_Park_I,_LLC_34.398252_-116.869667.csv",58417,117109.99,130472.22345540489,-13362.233455404887 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Lone_Valley_Solar_Park_II,_LLC_34.406096_-116.862059.csv",59237,241904.06999999998,260933.5133481494,-19029.44334814942 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Longboat_Solar,_LLC_34.904059_-117.103149.csv",60485,261403.03000000003,258267.31143779182,3135.7185622082034 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Madelyn_Solar,_LLC_34.768035_-117.323327.csv",59409,12808.050000000001,12472.184337114159,335.86566288584254 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Mitchell_Solar,_LLC_34.765216_-117.323349.csv",59411,17210.06,18708.45189538522,-1498.391895385219 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Navajo_Solar_Power_Generation_Station_1,_LLC_34.550338_-117.192742.csv",58610,21010.05,19540.691017136574,1469.358982863425 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Newberry_Solar_1,_LLC_34.853599_-116.683863.csv",58226,14781.02,19159.00130437211,-4377.981304372108 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Nunn_34.50918_-117.153822.csv,58448,12469.029999999999,13037.578016981675,-568.5480169816765 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Otoe_Solar_Power_Generation_Station_1,_LLC_34.544533_-117.192798.csv",58612,16660.030000000002,16134.599771568961,525.4302284310415 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Phelan_Pinon_Hills_CSD_Solar_34.578988_-117.579412.csv,63376,11113.029999999999,14320.20004279079,-3207.170042790791 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Powhatan_Solar_Power_Generation_Station_1,_LLC_34.496399_-117.143443.csv",58611,21590.05,19883.279816506136,1706.7701834938634 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_PVN_Milliken,_LLC_34.038508_-117.565779.csv",60790,24390.030000000002,30530.588391083074,-6140.558391083072 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_RE_Victor_Phelan_Solar_One,_LLC_34.51231_-117.481927.csv",58202,222418.03999999998,229603.73798518546,-7185.697985185485 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Rudy_Solar,_LLC_34.766753_-117.323333.csv",59410,16505.04,18708.361920827017,-2203.3219208270166 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SCE-Snowline-Duncan_Road_(North)_34.474054_-117.563433.csv,59359,16100.02,19740.57912322055,-3640.559123220548 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SCE-Snowline-Duncan_Road_(South)_34.471409_-117.561967.csv,59360,11361.000000000002,13160.582437316343,-1799.5824373163414 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SCE-Snowline-White_Rd_(Central)_34.415766_-117.46979.csv,59423,18535.98,19835.494088923315,-1299.5140889233153 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SCE-Snowline-White_Road_(North)_34.418022_-117.469811.csv,59422,18091.039999999997,19835.255000713572,-1744.2150007135751 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SCE-Snowline-White_Road_(South)_34.412889_-117.469435.csv,59421,16696.010000000002,19835.80762111392,-3139.7976211139176 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SEPV9_Power_Plant_34.189891_-116.091639.csv,58227,114416.01,109890.57595442835,4525.434045571645 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SEPV_2_34.174111_-116.152878.csv,58074,20030.030000000002,25919.384007027194,-5889.354007027192 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SEPV_8_34.171191_-116.153642.csv,58234,156039.01999999996,155518.84736885942,520.1726311405364 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Sheep_Creek_Community_Solar_Farm_34.571844_-117.575966.csv,65970,0.0,7882.737454632854,-7882.737454632854 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Stateline_Solar_35.587142_-115.428453.csv,58646,3227100.03,3251127.7564778803,-24027.726477880497 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_SunEdison_Walmart_Apple_Valley_DC_34.594302_-117.194878.csv,57012,10848.089999999998,11772.052659022287,-923.9626590222888 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Sunray_2_34.858925_-116.814282.csv,10437,291752.02999999997,255855.60956917875,35896.42043082122 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Sunray_3_34.862847_-116.831184.csv,10438,175382.02,176535.80185785447,-1153.781857854483 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Target_Shafter_34.112021_-117.273426.csv,61824,24939.04,35641.74833453512,-10702.70833453512 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Dry_Farm_Ranch_A_34.497624_-117.470659.csv,58418,49678.04,53245.2533675203,-3567.2133675203004 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Dry_Farm_Ranch_B_34.497824_-117.4723.csv,58419,48812.00000000001,53245.10905284896,-4433.109052848951 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Mesa_Linda_B2_34.512587_-117.387399.csv,59269,18685.990000000005,17406.22450924883,1279.765490751175 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Mesa_Linda_C2_34.511014_-117.387081.csv,59270,18768.05,17406.29207630659,1361.7579236934107 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Mesa_Linda_D2_34.509602_-117.387321.csv,59271,18731.03,17406.345270474067,1324.6847295259322 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Victor_Valley_CC_CPV_Solar_34.480112_-117.257817.csv,57254,8692.02,13041.76076650098,-4349.74076650098 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mupsy_Watts_3115_34.601219_-117.643653.csv,58454,17937.019999999997,24033.96585667516,-6096.945856675164 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Agua_Caliente_Solar_Project_32.981357_-113.498003.csv,57373,3597813.0,2931540.9605385116,666272.0394614884 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Arizona_Western_College_PV_32.686077_-114.495993.csv,57765,39642.02,72665.23238496437,-33023.212384964376 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Calipatria_Solar_Farm_33.165624_-115.531885.csv,59088,207342.03999999998,248054.2781677183,-40712.238167718315 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Calipatria_State_Prison_33.166494_-115.495569.csv,64521,47590.020000000004,62277.39696094934,-14687.37696094934 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Campo_Verde_Solar_32.745065_-115.726842.csv,58467,1692441.0499999998,1548688.4516470456,143752.59835295426 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Centinela_Solar_Energy_32.690795_-115.644149.csv,58430,2446491.059999999,2115915.830009268,330575.229990731 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Centinela_State_Prison_32.825456_-115.775311.csv,64519,51018.06,63245.251446033835,-12227.191446033838 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Citizens_Imperial_Solar_33.186401_-115.428877.csv,62052,255728.0,299354.64961860265,-43626.64961860265 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Community_Solar_1_32.983337_-115.481892.csv,58545,67502.04,74853.73284393591,-7351.692843935918 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Crown_Cooling_Facility_32.967109_-115.532695.csv,58527,4854.880000000001,10615.96106634561,-5761.081066345609 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Drew_Solar_LLC_32.69098_-115.667807.csv,63127,40017.0,252218.3120508837,-212201.3120508837 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Foothills_Solar_Plant_Hybrid_32.6395_-114.431353.csv,57997,487494.03,468077.52120022307,19416.50879977696 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Heber_Solar_32.714021_-115.540541.csv,58398,127580.02,124584.57733643509,2995.4426635649143 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Hyder_II_Hybrid_33.026566_-113.356482.csv,58383,185446.02999999997,174380.86247417997,11065.167525819998 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Hyder_Solar_Hybrid_33.027149_-113.348204.csv,57563,192142.03999999998,199291.8439642384,-7149.80396423841 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Imperial_Solar_Energy_Center_South_32.658612_-115.668611.csv,57490,1380993.0400000003,1377201.4882994685,3791.551700531738 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Imperial_Solar_Energy_Center_West_32.7622_-115.783372.csv,57491,1991459.0399999998,1882959.069657446,108499.97034255392 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Imperial_Valley_Solar,_LLC_32.675733_-115.596466.csv",56917,1891425.01,2573164.3480965393,-681739.3380965393 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Imperial_Valley_Solar_Company_1,_LLC_33.245914_-115.495117.csv",58062,196438.02,245476.619439834,-49038.59943983401 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Imperial_Valley_Solar_Co_(IVSC)_2,_LLC_33.252638_-115.497801.csv",59657,231007.01,212075.51360400606,18931.49639599395 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_IVC_Solar_32.831965_-115.506304.csv,61692,22724.01,37342.479924744526,-14618.469924744528 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Midway_Solar_Farm_III_33.158419_-115.531909.csv,60315,196323.00999999998,248063.2140783896,-51740.20407838962 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Midway_Solar_Farm_II_33.165443_-115.54063.csv,60237,386952.0,372081.1440492413,14870.855950758676 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Midway_Solar_Farm_I_33.165607_-115.54926.csv,60336,626321.0,620133.9327543597,6187.067245640326 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Mount_Signal_Solar_Farm_II_32.660359_-115.629932.csv,61353,1160034.0,1152337.715606721,7696.284393279115 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Mount_Signal_Solar_Farm_V_32.668292_-115.559746.csv,61202,2568611.0,3140672.14503368,-572061.1450336799 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_SEPV_Imperial_Dixieland_East_32.793446_-115.772764.csv,60745,27981.01,24055.520360321578,3925.4896396784206 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_SEPV_Imperial_Dixieland_West_32.793358_-115.781481.csv,60744,42601.049999999996,36716.225916420786,5884.824083579209 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Seville_1_33.116481_-116.001614.csv,59722,269311.03,251822.02640256495,17489.003597435076 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Seville_2_33.109168_-116.002991.csv,59723,422539.02999999997,376742.9499416958,45796.080058304186 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Solar_Gen_2_Solar_Facility_33.085561_-115.471515.csv,58592,1949416.9799999997,1929581.4403572045,19835.539642795222 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Sol_Orchard_El_Centro_PV_32.800989_-115.546392.csv,58621,219357.03999999998,248987.3744014914,-29630.33440149142 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Titan_Solar_1_(CA)_33.101457_-116.00026.csv,63932,406328.38,566837.0888164942,-160508.7088164942 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_USG_1_32.793208_-115.857433.csv,61682,12220.060000000001,12668.660633697786,-448.60063369778436 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_USG_2_32.790409_-115.863285.csv,61683,8953.040000000003,10696.538548649314,-1743.4985486493115 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Valencia_1_Solar_CA_33.043676_-115.627653.csv,61418,34759.05,31397.474920522283,3361.5750794777196 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Valencia_2_32.910699_-115.512279.csv,64267,15374.0,16614.48512885069,-1240.4851288506907 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Valencia_3_32.885328_-115.537213.csv,64441,14169.009999999998,14895.229966569816,-726.2199665698172 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Wistaria_Ranch_Solar_32.661415_-115.606286.csv,61750,1089333.0,1246438.5319260114,-157105.53192601143 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9mvgw4_Wister_Solar_33.273731_-115.505335.csv,63487,18853.010000000002,252115.7537796197,-233262.7437796197 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9pr8ne_Redwood_Coast_Airport_Microgrid_40.967375_-124.104405.csv,64766,730.0000000000001,6140.822871075609,-5410.822871075609 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Alpine_Solar_34.796534_-118.510081.csv,57295,800252.03,726215.7591742737,74036.27082572633 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_Big_Sky_Ranch_34.692615_-118.286334.csv,60279,267657.01000000007,257679.36100642377,9977.648993576295 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_DSR_1_34.656363_-118.281831.csv,60186,647966.0,645786.1915423365,2179.8084576635156 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_DSR_2_34.686845_-118.311932.csv,60187,67415.96999999999,64421.714159342584,2994.2558406574026 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_DSR_3_34.736999_-118.304021.csv,61265,160004.99,206645.37304116576,-46640.38304116577 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_Expansion_1B_34.716546_-118.261109.csv,62320,2438.0,219556.75799003767,-217118.75799003767 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_Expansion_2_34.742062_-118.302515.csv,61264,1012701.0,1355892.9672347587,-343191.96723475866 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_Expansion_3A_34.727487_-118.322374.csv,62673,68189.0,78421.93626043305,-10232.936260433053 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Antelope_Expansion_3B_34.720171_-118.322228.csv,62674,13396.02,13146.953241453353,249.06675854664718 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Arrache_4006_34.655113_-118.051145.csv,58445,11830.030000000002,23842.572729913933,-12012.54272991393 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Arrache_4013_34.650621_-118.051936.csv,58446,16948.019999999997,18604.87386374286,-1656.8538637428646 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Arrache_8083_34.647943_-118.061071.csv,58447,17097.05,49613.61853431815,-32516.56853431815 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_AVS_Lancaster_1_34.74775_-117.973128.csv,60085,42232.969999999994,40025.53759108603,2207.4324089139627 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_AV_Solar_Ranch_One_34.792128_-118.435099.csv,57378,2952411.0,2652333.794014981,300077.205985019 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Bayshore_Solar_A,_LLC_34.666021_-118.304269.csv",60481,269387.02,258299.46985495364,11087.550145046378 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Bayshore_Solar_B,_LLC_34.678046_-118.30456.csv",60474,264681.01,257698.64476088327,6982.365239116742 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Bayshore_Solar_C,_LLC_34.680778_-118.318921.csv",60475,260118.04,257695.2629255497,2422.777074450307 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Bolthouse_S&P_and_Rowen_Farms_Solar_34.564433_-117.694466.csv,56862,10395.08,15653.440828712432,-5258.360828712432 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Castaic_Lake_Phase_II_34.434336_-118.510139.csv,63385,23493.03,42654.28863980803,-19161.25863980803 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Central_Antelope_Dry_Ranch_B,_LLC_34.705692_-118.301453.csv",60281,41139.03,38649.19891497919,2489.831085020807 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Central_Antelope_Dry_Ranch_C_34.720632_-118.302392.csv,59963,175689.99999999997,218456.16587263442,-42766.16587263445 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_CSP_Los_Angeles_34.693768_-118.234071.csv,65182,585.01,6019.350611946349,-5434.340611946349 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Division_1_34.708325_-118.12854.csv,59094,13141.99,15834.462779556114,-2692.472779556114 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Division_2_34.708936_-118.129736.csv,59095,9503.03,9900.061708684992,-397.0317086849918 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Elevation_Solar_C_34.726891_-118.302936.csv,59964,555248.0,516573.10139823303,38674.89860176697 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Green_Beanworks_B_PV_34.688092_-117.989692.csv,61339,28581.050000000003,38834.34091886861,-10253.29091886861 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Green_Beanworks_C_PV_34.597412_-117.93146.csv,61215,31682.03,39104.19679009758,-7422.166790097581 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Green_Beanworks_D_PV_34.655127_-118.082255.csv,61216,31819.010000000006,38539.67571571378,-6720.665715713778 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Heliocentric_34.654388_-117.971144.csv,57831,11611.019999999999,14386.882017147738,-2775.8620171477396 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Horn_34.708588_-118.274109.csv,58452,16665.980000000003,18699.224028703535,-2033.2440287035315 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Irwindale_Brew_Yard,_LLC_34.122638_-117.939375.csv",58056,14651.18,28825.38404717655,-14174.20404717655 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Kettering_Solar_1_34.701058_-118.124893.csv,59098,9415.020000000002,9828.55629811655,-413.5362981165472 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Kettering_Solar_2_34.701868_-118.124822.csv,59099,9447.050000000001,10478.517239251234,-1031.467239251233 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_L-8_Solar_Project_34.654383_-117.973256.csv,57836,13417.04,14386.87712873104,-969.8371287310383 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Lancaster_34.743518_-117.972926.csv,62056,31227.03,38870.41387650472,-7643.3838765047185 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Lancaster_Baptist_Church_34.696333_-118.06252.csv,58634,8730.05,12821.244842146854,-4091.194842146855 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Lancaster_Dry_Farm_Ranch_B_34.716572_-118.291834.csv,58750,62333.02999999999,64575.31743721775,-2242.287437217761 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Lancaster_Little_Rock_34.603161_-117.936631.csv,59262,54658.05,55177.39299246451,-519.3429924645097 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Lancaster_WAD_B_34.779062_-118.19108.csv,59739,35023.03999999999,39158.37318922227,-4135.333189222278 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Las_Virgenes_34.131487_-118.701239.csv,64264,14141.980000000001,23449.875726913982,-9307.895726913981 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Las_Virgenes_Municipal_Water_District_34.132314_-118.699522.csv,58963,7434.06,11527.391408808915,-4093.3314088089146 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Little_Rock_Pham_Solar_34.600019_-117.949057.csv,60026,40710.04000000001,39103.587099289754,1606.4529007102537 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Maclay_Solar_Project_34.319539_-118.431426.csv,57308,3275.05,21193.41134514799,-17918.36134514799 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Ma_34.69513_-118.062578.csv,58451,16632.030000000002,19231.993390007934,-2599.9633900079316 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Morgan_Lancaster_1_34.662403_-118.084668.csv,59942,15381.01,19269.07549110891,-3888.0654911089096 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_North_Lancaster_Ranch_34.721409_-118.311349.csv,59962,174277.03,218455.4950017887,-44178.46500178869 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Occidental_College_Solar_Project_34.128028_-118.206682.csv,57311,7059.0,9864.741448748546,-2805.7414487485457 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_One_Ten_Partners_PV_34.6156_-117.936612.csv,61419,29374.059999999998,26066.881486985454,3307.1785130145436 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Portal_Ridge_Solar_B,_LLC_34.71651_-118.282251.csv",60310,244835.02999999997,258301.91783474002,-13466.887834740046 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Portal_Ridge_Solar_C,_LLC_34.714777_-118.27427.csv",60311,144012.01,147233.57603138048,-3221.566031380469 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Radiance_Solar_4_34.665582_-118.288133.csv,58354,16285.029999999999,16167.331852386296,117.69814761370253 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Radiance_Solar_5_34.664956_-118.286848.csv,58355,16343.04,16167.3834374243,175.65656257570117 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Rodeo_Solar_C2_34.712088_-118.290546.csv,58751,17849.000000000004,16295.401195776436,1553.5988042235676 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Rodeo_Solar_D2_34.711913_-118.291986.csv,58752,17623.030000000002,16295.361817364406,1327.6681826355962 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Rutan_34.64378_-118.162135.csv,58449,18164.04,49371.196033596345,-31207.156033596344 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_San_Pablo_Raceway_34.722176_-118.28079.csv,62004,920564.0,1033315.1869298286,-112751.1869298286 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_SEPV_18_34.613611_-117.936188.csv,59730,26137.059999999994,26067.166648059087,69.89335194090745 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_SEPV_1_34.618626_-117.939522.csv,58073,20569.020000000004,26066.407692364497,-5497.387692364493 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_SEPV_Palmdale_East_34.612272_-117.939586.csv,59273,128564.05,130076.0954593599,-1512.0454593598988 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Sierra_Solar_Greenworks_34.698237_-118.337643.csv,59431,203290.99,216054.83350577176,-12763.843505771772 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Solar_Oasis,_LLC_34.649011_-118.084924.csv",59528,269771.02999999997,256939.49660432612,12831.533395673847 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Solar_Star_1_34.814214_-118.388961.csv,58388,4413068.0,4080863.1478918116,332204.85210818844 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Solar_Star_California,_XLIV,_LLC_34.511888_-117.916406.csv",60869,123529.04000000001,124726.1153124008,-1197.0753124007897 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Solverde_1_34.655834_-118.294219.csv,60185,1094988.0,1097836.336366936,-2848.336366936099 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_North_Solar_34.727542_-118.296354.csv,58757,71499.06000000001,70503.14095215713,995.9190478428791 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_Solar,_LLC_34.714915_-118.311318.csv",60280,286273.04,258302.65643712712,27970.383562872856 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_Solar_A2_34.723656_-118.293789.csv,58753,18932.05,16295.15524422321,2636.8947557767897 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_Solar_B2_34.723645_-118.29251.csv,58754,18537.009999999995,16295.190376432069,2241.819623567926 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_Solar_C2_34.723647_-118.291641.csv,58755,17243.03,16295.209502058264,947.8204979417351 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Summer_Solar_D2_34.723625_-118.290664.csv,58756,10231.04,10863.493015205433,-632.4530152054322 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_TA-Acacia,_LLC_34.69278_-118.327867.csv",59443,274507.02999999997,253813.06388907426,20693.966110925714 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_TA-High_Desert,_LLC_34.707428_-118.304671.csv",58149,254136.05,258313.17632184725,-4177.1263218472595 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_US-TOPCO_(Soccer_Center)_34.661601_-118.086905.csv,60086,37141.02,32174.60275885103,4966.417241148967 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Vinam_34.669019_-118.061156.csv,58450,17868.989999999998,18568.10470126597,-699.1147012659712 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Western_Antelope_Blue_Sky_B_34.727199_-118.313086.csv,59961,275859.04,258285.51978012623,17573.520219873753 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Western_Antelope_Blue_Sky_Ranch_A_34.687307_-118.319773.csv,58626,249523.02,257042.07343531717,-7519.053435317182 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Western_Antelope_Dry_Ranch_34.72545_-118.308755.csv,58627,131761.02000000002,129143.97030170188,2617.049698298142 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5fm0_Weymouth_Solar_Plant_34.108438_-117.785098.csv,60255,26922.020000000004,35679.08459648761,-8757.06459648761 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q5sgb_California_State_Univ_at_Channel_Islands_34.168862_-119.053959.csv,64403,6986.02,17807.25603885842,-10821.23603885842 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_Atascadero_State_Hospital_35.4706_-120.634865.csv,64523,5066.01,8375.99073675757,-3309.9807367575704 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_CA-DGS-California_Men's_Colony_35.321552_-120.69217.csv,65523,0.0,4673.817876886809,-4673.817876886809 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_California_Valley_Solar_Ranch_35.317457_-119.925656.csv,57439,3071991.05,3141551.740739857,-69560.69073985703 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_Firestone_Walker_Brewery-Phase_1_35.596047_-120.689531.csv,64391,6595.04,12064.993711090665,-5469.953711090665 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_Stenner_Creek_Solar_35.319611_-120.69101.csv,61607,47669.03,55344.64714900535,-7675.617149005353 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_Topaz_Solar_Farm_35.368633_-120.03261.csv,57695,6396363.0,6198811.575465672,197551.42453432828 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q613c_Vintner_Solar_35.557914_-120.681818.csv,58509,20631.059999999998,18570.819908938396,2060.2400910616016 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Adobe_Solar_35.103963_-118.954207.csv,57651,233841.99,232649.43900018002,1192.5509998199705 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Algonquin_SKIC_10_Solar,_LLC_35.127755_-119.249344.csv",60242,99334.06,118508.5193131921,-19174.4593131921 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Algonquin_SKIC_20_Solar,_LLC_35.1246_-119.240648.csv",59412,237611.03000000003,261080.64982827258,-23469.619828272553 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Bakersfield_111_35.31479_-118.988977.csv,59948,12797.039999999999,16629.843105162978,-3832.8031051629787 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Bakersfield_Industrial_PV_1_35.329997_-118.993189.csv,61118,10756.04,9946.069456554424,809.9705434455773 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Bakersfield_PV_1_35.3268_-118.978771.csv,61117,49376.01,62358.191267724666,-12982.181267724663 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Beacon_Solar_Plant_Site_2_35.259453_-117.998736.csv,59309,630250.0,579966.1208002805,50283.87919971952 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Beacon_Solar_Plant_Site_5_35.247032_-118.034774.csv,59308,501081.0,464002.5558344813,37078.44416551868 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_BigBeau_Solar,_LLC_34.915421_-118.35518.csv",64993,358508.09,347028.0532794106,11480.036720589444 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Blackwell_Solar_Park_35.608789_-119.844433.csv,59524,183649.02000000002,193763.96555677865,-10114.945556778635 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Calibrant_Bakersfield,_LLC_35.442009_-119.093343.csv",65564,2176.02,3171.9184659385264,-995.8984659385264 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_California_City_35.157379_-117.983395.csv,63516,21707.02,24791.86706434039,-3084.847064340389 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Cal_City_Solar_1_35.141539_-117.964708.csv,63054,23745.01,31486.699764802433,-7741.689764802435 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Castor_Solar_35.21097_-119.387524.csv,60277,13905.029999999999,15329.111700142148,-1424.0817001421492 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Catalina_Solar,_LLC_34.929474_-118.333067.csv",57708,1280713.06,1205796.463763544,74916.59623645595 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Catalina_Solar_2,_LLC_34.926989_-118.357016.csv",59334,251628.02000000002,244233.64463301774,7394.375366982276 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_CDCR_(CA)-Wasco_State_Prison_35.590887_-119.404787.csv,61621,16719.03,17763.74714343158,-1044.7171434315824 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Chevron-Lost_Hills_Hybrid_35.609422_-119.7013.csv,63545,205425.0,209481.6278018496,-4056.627801849594 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Coronal_Lost_Hills_35.727086_-119.905588.csv,59638,248379.02,239950.59968710356,8428.42031289643 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Cottonwood_Solar,_LLC_(Goose_Lake)_35.590715_-119.576132.csv",59086,163970.02000000002,142280.03411086486,21689.98588913516 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Cuyama_Solar,_LLC_34.901577_-119.590942.csv",60043,476721.0,507202.4387154521,-30481.438715452095 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Delano_Land_1_35.759177_-119.348351.csv,61116,9133.06,11806.56727937507,-2673.5072793750696 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_EAFB-North_Base_34.982066_-117.892042.csv,59132,12558.03,14571.0250033656,-2012.9950033655987 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Eagle_Creek_35.213746_-119.39509.csv,63078,24967.040000000005,29028.46847680122,-4061.428476801215 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Air_Force_Base_34.907637_-117.920591.csv,58076,8811.05,39409.746268938,-30598.696268937998 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_E1A_34.96308_-118.096328.csv,64878,58888.0,793206.3698468413,-734318.3698468413 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_E2_34.944318_-118.087282.csv,64879,350736.0,735180.0009509015,-384444.00095090154 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_E3_34.942287_-118.135456.csv,64877,61698.0,146181.96951619125,-84483.96951619125 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_S1_35.018581_-118.124089.csv,64929,94005.0,237011.3758745031,-143006.3758745031 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_S3_34.991851_-118.100955.csv,64928,80225.0,100836.99478603464,-20611.994786034644 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Edwards_Sanborn_S4_34.973444_-118.08851.csv,65677,10129.0,110100.8967587254,-99971.8967587254 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Gaskell_West_1_Solar_Facility_34.836923_-118.550114.csv,61445,257227.99000000002,260419.1134175845,-3191.1234175844875 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Golden_Fields_Solar_I,_LLC_34.840448_-118.391134.csv",60590,703043.0,703771.7932964249,-728.7932964249048 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Golden_Field_Solar_III,_LLC_34.830055_-118.371047.csv",63859,1162471.0,1502210.2527037684,-339739.25270376843 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Hayworth_Solar_35.328168_-118.82064.csv,59009,279683.02,315861.09013708256,-36178.07013708254 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Hecate_Energy_Beacon_Solar_1_35.268579_-118.014746.csv,59315,702902.0,722366.5529905419,-19464.55299054191 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Hecate_Energy_Beacon_Solar_3_35.248541_-118.009058.csv,59316,700103.0,721778.0529308637,-21675.05293086369 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Hecate_Energy_Beacon_Solar_4_35.251895_-118.025072.csv,59317,620964.0,644431.8808739672,-23467.880873967195 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Improvement_Dst_No._4_35.402755_-119.038053.csv,57895,4123.009999999999,11010.211609498429,-6887.201609498429 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Kingbird_A_Solar,_LLC_34.824081_-118.441196.csv",59868,290188.04,259582.0177836377,30606.022216362267 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Kingbird_B_Solar,_LLC_34.820843_-118.441155.csv",60091,289220.00999999995,259586.5307146756,29633.47928532434 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Lost_Hills_Blackwell_35.625756_-119.854284.csv,58711,437876.01000000007,386652.7855215585,51223.22447844158 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Maricopa_West_Solar_PV,_LLC_35.112311_-119.326746.csv",59607,216067.03,237036.66892811516,-20969.638928115164 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Morelos_del_Sol_35.728102_-119.896814.csv,60007,179894.05000000002,179975.92156057066,-81.8715605706384 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Naval_Air_Weapons_Station_China_Lake_35.634879_-117.652331.csv,57764,125342.99999999999,142961.20827817867,-17618.20827817869 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Nickel_1_Solar_Facility_35.647639_-119.716317.csv,58034,12526.07,15158.672820478376,-2632.602820478376 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_North_Kern_State_Prison_Phase_II_35.777221_-119.308162.csv,63651,30850.0,47222.32558163819,-16372.325581638193 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Orion_Solar_II_35.148877_-118.885279.csv,58721,79056.07000000002,94978.60715007853,-15922.537150078511 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Orion_Solar_I_35.146166_-118.887207.csv,58718,184036.06,142469.87973287015,41566.18026712985 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Pine_Tree_Solar_Project_35.229696_-118.193516.csv,57306,58509.079999999994,96682.57495864308,-38173.49495864308 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Pumpjack_Solar_I_35.416024_-119.638251.csv,59322,245410.02000000002,238916.693737432,6493.326262568007 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Rabbitbrush_Solar,_LLC_34.873741_-118.353732.csv",64630,50232.0,265643.6468361514,-215411.64683615143 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Redcrest_Solar_Farm_35.321135_-118.812196.csv,58831,174491.02,197390.5928199413,-22899.5728199413 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Redwood_4_Solar_Farm_35.315109_-118.811155.csv,60490,298919.01000000007,236970.7508888204,61948.25911117968 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Regulus_Solar_Project_35.299856_-118.846316.csv,57650,784692.03,710304.8206009842,74387.20939901588 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Astoria_2_34.829497_-118.470955.csv,59977,1127709.0,976619.2531476407,151089.74685235927 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Astoria_34.844248_-118.446156.csv,59976,1448526.0,1303126.91052558,145399.08947442006 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Barren_Ridge_1_35.205168_-118.069512.csv,60389,849692.9999999999,818694.8942468388,30998.10575316113 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Camelot,_LLC_35.02331_-118.172402.csv",58983,614371.04,591689.568081107,22681.471918893047 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Columbia_3,_LLC_35.017969_-118.171566.csv",58502,114590.04999999999,131490.49762631065,-16900.447626310663 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Columbia_Two,_LLC_35.012711_-118.182571.csv",58990,206189.03,197241.19184232753,8947.838157672464 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Garland_34.822187_-118.527993.csv,60233,2421838.0599999996,2343963.999506768,77874.06049323175 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Garland_A_34.821143_-118.497643.csv,60386,288361.0,260443.12637863847,27917.873621361534 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Gaskell_West_5,_LLC_34.84588_-118.543361.csv",61449,0.0,262100.79240405333,-262100.79240405333 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Old_River_One,_LLC_35.218894_-119.0791.csv",58986,238072.96999999997,232426.22626640814,5646.743733591837 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Rio_Grande_Solar,_LLC_35.048908_-118.163909.csv",58500,52306.04,65829.03184204164,-13522.991842041643 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Rosamond_One,_LLC_34.904113_-118.251246.csv",58498,290179.01999999996,262609.9366076097,27569.083392390283 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_RE_Rosamond_Two,_LLC_34.903488_-118.242989.csv",58499,222396.03999999998,262787.5115946271,-40391.47159462713 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Rio_Bravo_Solar_1,_LLC_35.415837_-119.629409.csv",59249,241446.98,232944.0378384452,8502.94216155482 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Rio_Bravo_Solar_II,_LLC_35.423854_-119.628933.csv",59250,244174.02000000002,232935.1058805224,11238.914119477617 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_SEPV_Mojave_West_35.020441_-118.278367.csv,59740,276896.05,264456.96422080597,12439.085779194022 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Shafter_Solar,_LLC_35.450699_-119.127026.csv",59408,253880.00000000003,239162.24019314742,14717.759806852613 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Solar_Star_2_34.829726_-118.441152.csv,58389,3861350.0,3627551.8622528897,233798.13774711033 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Solar_Star_California,_XLI,_LLC_34.830259_-118.392372.csv",60591,698079.0,700851.2863983581,-2772.286398358061 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Springbok_3_Solar_Farm_Hybrid_35.283293_-118.010494.csv,60491,828065.0,929556.6436936778,-101491.64369367785 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Springbok_Solar_Farm_1_35.251658_-117.956571.csv,59532,1485453.03,1353177.9782209664,132275.05177903362 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Springbok_Solar_Farm_2_35.24881_-117.973623.csv,59840,2069891.0299999998,1997577.1529651154,72313.87703488441 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Valentine_Solar,_LLC_34.91039_-118.391826.csv",62288,785131.0,1164166.6273192829,-379035.62731928285 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Vandenberg_Solar_Project_34.745094_-120.510241.csv,61463,215997.01,255424.17825195674,-39427.168251956726 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wildwood_Solar_I,_LLC_35.61905_-119.568936.csv",59380,237206.05,237101.8834396922,104.1665603077854 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wildwood_Solar_II_35.631892_-119.576691.csv,59253,190090.04,175206.23271790845,14883.807282091555 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Willow_Spring_Solar,_LLC_34.825924_-118.332041.csv",60324,1052316.0,1041699.9033879739,10616.0966120261 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Windhub_Solar_A,_LLC_35.021659_-118.28987.csv",59878,145689.0,211706.49786313777,-66017.49786313777 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wonderful_Huller_&_Shellling_35.575751_-119.786573.csv,65277,6389.620000000001,7358.6160538964305,-968.9960538964297 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wonderful_Lost_Hills_35.668165_-119.876218.csv,65278,53382.04,81455.49103617748,-28073.45103617748 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wonderful_Orchards-Belridge_35.501224_-119.748744.csv,64221,20231.010000000002,36184.790232801424,-15953.780232801422 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Wonderful_Orchards-Westside_35.734373_-119.732276.csv,64220,17820.010000000002,24044.423141252675,-6224.413141252673 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q713t_Woodmere_Solar_Farm_35.323547_-118.820816.csv,59008,175875.00999999998,177601.91710597748,-1726.9071059775015 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q8yqr_Sunset_Reservoir_North_Basin_37.750828_-122.483522.csv,57559,32629.07,37516.18522293452,-4887.115222934517 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_CA_Flats_Solar_130,_LLC_35.872013_-120.339384.csv",60033,1679952.0,1600415.0668649168,79536.93313508318 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_CA_Flats_Solar_150,_LLC_35.829895_-120.294871.csv",60034,1416568.0,1486849.8427646172,-70281.84276461718 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_D'Arrigo_Brothers-Phase_4_36.614777_-121.634165.csv,63486,15207.02,16270.674492349268,-1063.6544923492675 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_Enerparc_CA1,_LLC_36.831899_-121.404082.csv",59122,16562.01,15254.69181979132,1307.3181802086783 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_Graniterock_Quarry_36.875559_-121.603662.csv,65485,2538.0,8950.254745602178,-6412.254745602178 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_Hollister_Solar,_LLC_36.862421_-121.428902.csv",59268,19940.04,17723.897822865725,2216.1421771342757 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_Monterey_Regional_Water_Pollution_Control_Agency_36.708224_-121.76899.csv,58633,6191.020000000001,10690.324073776821,-4499.30407377682 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q92vz_Panoche_Valley_Solar_Farm_36.629772_-120.891311.csv,57340,1592247.0,1737143.6654079657,-144896.66540796566 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_2097_Helton_Solar_Project_37.350917_-120.50723.csv,58920,15773.02,17368.649656047564,-1595.629656047564 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Merced_1_PV_36.989439_-120.878325.csv,61420,31272.040000000005,35677.88583299061,-4405.8458329906025 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Merced_Solar,_LLC_37.268698_-120.483314.csv",59265,18913.989999999998,17300.96588233581,1613.0241176641866 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Mission_Solar,_LLC_37.267336_-120.483318.csv",59267,19060.039999999997,17301.074821533468,1758.9651784665293 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Quinto_Solar_PV_Project_37.120708_-121.038838.csv,59339,1365812.0200000003,1247439.8369111614,118372.18308883882 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Sun_Harvest_Solar_NDP1_37.057787_-120.649009.csv,59687,13347.000000000002,17615.043755403407,-4268.043755403405 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Vega_Solar_36.928591_-120.805293.csv,59555,240687.02999999997,237921.0384464911,2765.9915535088803 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9fy1_Wright_Solar_Park_37.018864_-120.961889.csv,59525,1472332.0,1955548.4323293555,-483216.4323293555 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9hq4_Guadalupe_Solar_Farm_37.268874_-121.861077.csv,62690,11832.040000000003,16194.821453153018,-4362.781453153015 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9hq4_Hellyer_Solar_Farm_37.286885_-121.814147.csv,62689,15687.99,20788.02137713913,-5100.031377139132 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9hq4_Malech_Solar_Farm_37.228465_-121.738711.csv,62688,22585.010000000002,29696.964881494725,-7111.954881494723 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9m24_City_of_Hayward_WWTP_37.633492_-122.139854.csv,58525,15181.979999999998,18640.309354964196,-3458.3293549641985 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9m24_Whitethorn_Solar,_LLC_37.69203_-121.717394.csv",60193,30218.039999999997,32449.631578346623,-2231.591578346626 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9wtp_Bear_Creek_Solar_38.135935_-121.148813.csv,58508,18924.03,17575.668354468075,1348.3616455319243 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9wtp_Foothill_Sanitary_Landfill-Solar_Array_38.042111_-120.936076.csv,65089,17595.01,16477.72054574645,1117.2894542535469 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9wtp_Kettleman_Solar_Project_38.121389_-121.140603.csv,58510,12864.019999999999,11649.288963879775,1214.7310361202235 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9q9wtp_Manteca_Land_PV_37.840203_-121.215228.csv,61115,9327.99,9836.880939037548,-508.8909390375484 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qbbed_Silveira_Ranch_Road_Solar_38.156019_-122.566002.csv,63762,10367.010000000002,12283.69915675673,-1916.6891567567272 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qbcde_American_Canyon_Solar_38.160723_-122.213851.csv,62687,22382.03,28292.73349861039,-5910.70349861039 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qbcde_Soscol_Ferry_Solar_38.237461_-122.275553.csv,63761,10648.029999999999,14162.013178407651,-3513.9831784076523 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Cloverdale_Solar_Center_38.769502_-123.020736.csv,60813,8319.01,9196.301546282653,-877.2915462826531 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Cloverdale_Solar_I_38.774443_-123.017277.csv,58949,5539.010000000001,14604.874563734871,-9065.86456373487 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Dissigno_Healdsburg_FPV,_LLC_38.583694_-122.864523.csv",64308,12364.0,13664.780959757183,-1300.7809597571832 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Lavio_Solar_38.194832_-122.663198.csv,61792,9956.050000000001,10097.027115148694,-140.97711514869297 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Stage_Gulch_Solar_38.21671_-122.542807.csv,61791,8809.01,8061.180167830096,747.829832169904 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qben2_Windsor_Floating_Solar_38.539113_-122.815051.csv,62902,5715.0,8504.076239422657,-2789.0762394226567 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_Bio-Rad_38.025122_-122.274498.csv,63189,4425.0199999999995,14378.953033198633,-9953.933033198635 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_Byron_Highway_Solar_37.847138_-121.616824.csv,64471,1524.6,24064.231263603404,-22539.631263603405 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_California_PV_Energy_at_ISD_WWTP_38.00172_-121.703675.csv,59283,7252.0,10174.163674086172,-2922.1636740861723 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_Columbia_Solar_Energy,_LLC_38.019462_-121.86437.csv",59979,167069.01000000004,192251.437562674,-25182.427562673955 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_CSD_2-Freedom_High_37.972281_-121.720347.csv,59129,7123.029999999999,10794.473615761612,-3671.443615761613 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_CSD_2-Heritage_High_37.920586_-121.755782.csv,59130,9686.980000000001,11835.733869429587,-2148.7538694295854 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc0p1_Marin_Clean_Energy_Solar_One_37.94522_-122.378508.csv,61013,104534.04000000001,130480.68419010204,-25946.64419010203 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_CDCR_(CA)-Solano_State_Prison_38.325498_-121.98267.csv,61619,10887.999999999998,13101.074283635371,-2213.074283635373 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Genentech_Vacaville_Meter_#1_38.386449_-121.948811.csv,60844,59342.04,62011.402572591614,-2669.3625725916136 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Grassland_1&2_Solar_Project_38.500651_-121.692985.csv,58217,19074.000000000004,29320.12429327135,-10246.124293271347 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Grassland_3&4_Solar_Project_38.50153_-121.693001.csv,58204,17968.059999999998,29319.991952298155,-11351.931952298157 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Lake_Herman_38.097105_-122.140918.csv,64676,9812.009999999998,24373.97104591427,-14561.961045914271 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Mariani_Packing_Vacaville_Solar_38.400022_-121.964362.csv,57005,7017.03,9948.63689853127,-2931.6068985312695 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_North_Bay_Solar_1_38.301001_-121.965191.csv,58748,10357.059999999998,11889.584429484501,-1532.5244294845033 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Putah_Creek_Solar_Farm_38.520977_-121.994077.csv,59550,24936.03,23618.529867031462,1317.5001329685365 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_SunEdison_Anheuser_Busch_Fairfield_38.231937_-122.092698.csv,57010,8026.060000000001,10670.778726766492,-2644.7187267664904 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_UC_Davis_South_Campus_38.520096_-121.740353.csv,59872,142010.03,152512.26695600565,-10502.236956005654 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Vacaville_38.400027_-121.962908.csv,59058,8870.01,8351.39696567304,518.6130343269597 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Vaca_Dixon_Solar_Station_38.410856_-121.926425.csv,57041,17756.039999999997,20267.95291991177,-2511.912919911774 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qc63x_Yolo_County_Solar_Project_38.657468_-121.733703.csv,57422,6137.9800000000005,11577.587489349404,-5439.607489349403 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcbq0_Axium_Modesto_Solar_37.736402_-120.988417.csv,58039,310554.01999999996,299418.6205203066,11135.399479693384 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcbq0_Central_40_37.248616_-121.108704.csv,63940,182971.0,192438.34728904936,-9467.347289049358 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcbq0_Frontier_Solar,_LLC_37.366707_-121.151644.csv",60039,252911.05000000002,242043.67823958595,10867.37176041407 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcbq0_Robert_O_Schulz_Solar_Farm_37.858419_-120.895417.csv,57579,11332.029999999999,15045.921275039931,-3713.891275039932 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcbq0_Sonora_1_37.890378_-120.525809.csv,58578,18455.989999999994,17441.516854645648,1014.4731453543463 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Aerojet_II_38.611219_-121.168241.csv,57698,19506.030000000002,29934.76329762196,-10428.733297621959 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Aerojet_I_38.613694_-121.162278.csv,57697,28511.050000000003,33260.49180384827,-4749.441803848269 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Depot_Park_Solar_System_38.515353_-121.401009.csv,58119,21487.359999999997,34729.33750343807,-13241.977503438076 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_FAA_NorCal_TRACON_38.56146_-121.259196.csv,58261,6933.05,11523.32579801644,-4590.27579801644 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Green_Acres_Solar_Facility_1_38.282099_-121.465542.csv,57849,29106.029999999995,32774.52516232709,-3668.4951623270936 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Green_Acres_Solar_Facility_2_38.28355_-121.461629.csv,57850,10414.04,10534.582092805911,-120.54209280591022 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Intel_Folsom_38.644086_-121.172447.csv,58086,7583.01,11304.849124952638,-3721.8391249526376 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Rancho_Seco_Solar,_LLC_38.343177_-121.116734.csv",60226,109852.03000000001,125735.23631175375,-15883.206311753733 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Rancho_Seco_Solar_II,_LLC_38.34787_-121.111904.csv",63387,539020.0,925052.7402635218,-386032.7402635218 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_Bruceville_1,_LLC_38.347677_-121.41057.csv",57783,54742.03,58307.25377554005,-3565.2237755400492 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_Dillard_1,_LLC_38.469518_-121.182478.csv",57777,28844.030000000002,34664.888868006215,-5820.858868006213 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_Dillard_2,_LLC_38.466028_-121.178084.csv",57779,28652.019999999997,34665.524231032294,-6013.504231032297 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_Dillard_3,_LLC_38.463103_-121.180088.csv",57781,31484.039999999997,34666.06303705744,-3182.0230370574463 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_Kammerer_1,_LLC_38.363565_-121.385352.csv",57778,56438.09,58302.2409566335,-1864.1509566335008 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_1,_LLC_38.305711_-121.28454.csv",57816,58830.07,348222.30887149024,-289392.23887149023 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_2,_LLC_38.306491_-121.294925.csv",57817,59770.0,58036.8325179909,1733.1674820090993 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_3,_LLC_38.304693_-121.289996.csv",57818,59770.99999999999,58037.355448168026,1733.644551831967 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_4,_LLC_38.304692_-121.292451.csv",57819,59380.01000000001,58037.37571432655,1342.6342856734627 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_5,_LLC_38.309456_-121.292343.csv",57820,59508.03000000001,58035.918126147684,1472.1118738523292 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_RE_McKenzie_6,_LLC_38.309187_-121.290032.csv",57821,59226.02999999999,58036.02465598239,1190.005344017598 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Sacramento_(SMUD)_38.585226_-121.467197.csv,59323,6610.01,13306.805348566188,-6696.795348566187 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Sacramento_Fairbain_Water_Treatment_Plant_38.554789_-121.417088.csv,58636,5831.03,11574.00625403877,-5742.97625403877 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Sacramento_Regional_County_Sanitation_PV_38.436229_-121.466262.csv,61209,37295.020000000004,40770.87542844844,-3475.8554284484344 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Sacramento_Soleil,_LLC_38.450118_-121.164255.csv",56875,4343.0199999999995,9651.86265538193,-5308.842655381931 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_SCDA_Solar_1_38.700215_-121.586726.csv,61006,59581.04000000001,78810.67890175585,-19229.63890175584 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_SMUD_at_Lawrence_38.338753_-121.431259.csv,57753,8585.050000000001,9620.678566177115,-1035.6285661771144 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Solar_Star_California_II,_LLC_38.516214_-121.475657.csv",57933,16071.02,23165.937156745575,-7094.917156745574 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcem3_Wildflower_Solar_1_38.70464_-121.47783.csv,62988,62666.01,95761.01029031482,-33095.00029031482 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcggm_Deer_Creek_2_38.629169_-120.982653.csv,64861,3184.99,5122.308423009086,-1937.3184230090865 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcggm_El_Dorado_County_38.69854_-120.830676.csv,64402,5430.999999999999,5856.146269872706,-425.1462698727073 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qcggm_El_Dorado_Solar,_LLC_38.638284_-121.056063.csv",64700,5185.040000000001,5899.396702729262,-714.3567027292611 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qct8r_2127_Harris_Solar_Project_39.291776_-121.669962.csv,58919,11932.01,14577.8692856551,-2645.8592856551004 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_2081_Terzian_Solar_Project_36.66739_-119.416708.csv,58918,11192.03,13757.455061528266,-2565.4250615282654 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Adera_Solar_37.120529_-120.324509.csv,60027,175698.03,195908.2895603162,-20210.25956031619 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Aspiration_G_36.54837_-120.345676.csv,59737,108395.04000000001,105281.41624506137,3113.6237549386424 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Borden_Solar_Farm_36.941297_-119.963177.csv,59531,314534.0,344945.0447504639,-30411.044750463916 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_CalRenew-1_36.759626_-120.365926.csv,56768,41746.009999999995,48597.416835128366,-6851.406835128371 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Cantua_Solar_Station_36.424422_-120.341163.csv,57522,201919.04,200035.13291004652,1883.9070899534854 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_CA_-_Fresno_County_-_Juvenile_Hall_36.659011_-119.732805.csv,65528,6270.0,6609.381211108638,-339.3812111086381 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_CA_-_Madera_USD_-_Madera_South_HS_36.957241_-120.034258.csv,65615,0.0,2795.8742706330895,-2795.8742706330895 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_CDCR_(CA)-Pleasant_Valley_State_Prison_36.126063_-120.247782.csv,59748,14634.02,14397.382636357483,236.6373636425178 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Citizen_B_36.721849_-120.430096.csv,59738,42038.01,49650.92754471143,-7612.917544711425 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_City_of_Madera_WWTP_36.942735_-120.158887.csv,57682,7353.0199999999995,11480.250302798166,-4127.230302798166 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_DGS_Valley_State_Prison_37.087619_-120.150381.csv,63947,7950.029999999999,10647.278385318268,-2697.2483853182694 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_DSH_(CA)-Coalinga_State_Hospital_36.126665_-120.243255.csv,59746,20864.039999999997,31293.76748066069,-10429.727480660691 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Fifth_Standard_Solar_PV,_LLC_(Hybrid)_36.159538_-120.111946.csv",64197,0.0,1071700.426092659,-1071700.426092659 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Firebaugh-CCS-PV-1_36.73465_-120.614743.csv,63994,4702.98,9985.024116546923,-5282.044116546924 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Five_H_Farms_Solar_Array_37.10966_-120.298292.csv,65168,2118.03,4286.596298405817,-2168.5662984058167 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Five_Points_Solar_Park_36.391972_-120.243421.csv,59523,722377.03,701111.705690074,21265.324309926014 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Five_Points_Solar_Station_36.395424_-120.107782.csv,57498,117979.03,148313.53007501204,-30334.500075012038 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Fresno_Solar_36.616892_-120.105121.csv,60083,31376.019999999993,34814.36466815782,-3438.3446681578243 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Gap_Pacific_Distribution_Center_36.783741_-119.714009.csv,56909,18904.05,13780.914373639911,5123.135626360088 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Gates_Solar_Station_36.175836_-120.115552.csv,57892,161240.00999999998,200899.94559677583,-39659.935596775846 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Giffen_36.527411_-120.313283.csv,57521,82622.05999999998,99577.2404094994,-16955.180409499415 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Giffen_Solar_Park_36.554384_-120.339146.csv,59522,157736.99000000002,233939.0000578248,-76202.01005782478 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Great_Valley_Solar_Portfolio_Holdings,_LLC_36.585348_-120.383854.csv",59940,2681122.0,2344311.920909679,336810.07909032097 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Huron_Solar_Station_36.177598_-120.109391.csv,57523,183210.03,200899.9269200758,-17689.896920075815 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_La_Joya_Del_Sol_36.678879_-119.79754.csv,58118,7621.0199999999995,17357.54537037938,-9736.525370379379 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Little_Bear_3_36.716376_-120.391855.csv,62463,101647.03,140647.58205284656,-39000.55205284656 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Little_Bear_4_36.709025_-120.414381.csv,62464,211314.0,351633.3527733958,-140319.35277339577 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Little_Bear_5_36.709126_-120.396648.csv,62465,210047.0,351631.4689147003,-141584.46891470032 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Little_Bear_Solar_1,_LLC_36.716336_-120.414267.csv",59870,179512.0,281296.938385895,-101784.93838589499 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Madera_1_PV_37.056276_-120.167303.csv,61421,14435.080000000002,17166.842338863287,-2731.7623388632855 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Madera_Community_Hospital_36.941045_-120.046435.csv,58522,9787.010000000002,11475.379751686794,-1688.3697516867924 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Moonlight_Packing-Phase_2_36.585029_-119.470066.csv,63514,11238.03,10922.06612881802,315.9638711819807 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_National_Raisin_36.620589_-119.668046.csv,61894,23565.020000000004,28999.37366925807,-5434.353669258067 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_NextEra_Westside_PV_36.382014_-120.1345.csv,60981,258114.00999999998,233420.89942538878,24693.1105746112 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_North_Star_Solar_36.730527_-120.415146.csv,58713,719923.0199999999,730092.8540000201,-10169.834000020172 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Oro_Loma_36.876816_-120.667732.csv,59915,254140.1,236364.08553388694,17776.01446611306 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Pacific_Ethanol_Madera_Solar_Array_36.91629_-119.971615.csv,61989,18000.020000000004,44759.007642583514,-26758.98764258351 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_RE_Adams_East,_LLC_36.613282_-120.383494.csv",58984,230022.05,222666.07475240572,7355.975247594266 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_RE_Tranquillity_36.570855_-120.399372.csv,59939,2345515.0499999993,2409185.2195353103,-63670.16953531094 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_San_Joaquin_Solar_36.522085_-120.146373.csv,60678,139623.04,171544.40733231403,-31921.367332314025 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Sealed_Air_Madera_Solar_Project_36.946456_-120.077629.csv,65469,3.01,6986.157926661145,-6983.147926661145 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Stroud_Solar_Station_36.52382_-120.123306.csv,57497,166062.03,196909.55998348034,-30847.529983480345 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Tranquillity_ID_36.648126_-120.24633.csv,64376,9164.04,15058.794237423703,-5894.754237423702 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Westlands_Solar_PV_Farm_36.127567_-120.142064.csv,58616,210246.01999999993,213383.7180476033,-3137.698047603364 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Westside_Solar_Station_36.37817_-120.123959.csv,57499,119299.03,148848.49769244887,-29549.467692448874 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_West_Gates_Solar_Station_36.141884_-120.132734.csv,58206,97196.04999999999,100572.66061418048,-3376.610614180492 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Whitney_Point_Solar_36.374847_-120.134212.csv,60975,263795.03,233428.5969070391,30366.433092960942 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qd9xh_Wonderful_Orchards-New_Columbia_36.825592_-120.318359.csv,64055,21065.0,29832.341405542546,-8767.341405542546 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Almond_36.148542_-119.914298.csv,62546,0.0,94548.10752021467,-94548.10752021467 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Alpaugh_50_35.901922_-119.438642.csv,58003,587492.0200000001,585477.9307043987,2014.0892956014723 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Alpaugh_North_35.909054_-119.426903.csv,58002,229389.03999999998,234183.37531801712,-4794.33531801714 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_American_Kings_Solar,_LLC_36.249391_-119.900317.csv",60777,604383.0,900641.2410395821,-296258.24103958206 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Aquamarine_36.204642_-119.917678.csv,62547,764603.0,1184558.125419435,-419955.1254194351 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Atwell_Island_35.815505_-119.451017.csv,58366,183277.03000000003,199406.00201742596,-16128.972017425927 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Atwell_Island_West_Solar_35.81509_-119.459675.csv,59414,241476.01,235571.34074788337,5904.669252116641 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Avenal_Park_35.990852_-120.106656.csv,57359,53987.07,61622.817717972604,-7635.747717972605 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Castle_Rock_Vineyards_35.801176_-119.110889.csv,57870,5818.06,9841.460593928043,-4023.4005939280423 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CDCR_(CA)-Corcoran_State_Prison_36.064473_-119.5605.csv,61620,38422.03,58312.380164688446,-19890.350164688447 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CED_Avenal_35.996053_-120.151899.csv,60077,178555.01,191391.92083456792,-12836.910834567912 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CED_Ducor_1_35.855438_-119.068501.csv,60078,243262.03999999998,233633.13271168876,9628.907288311224 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CED_Ducor_2_35.846421_-119.065818.csv,60079,243806.04000000004,233642.8558160372,10163.184183962847 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CED_Ducor_3_35.845551_-119.057005.csv,60080,182721.03999999998,175232.8718425938,7488.16815740618 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CED_Ducor_4_35.850283_-119.026032.csv,60081,241801.05,234090.14212664738,7710.907873352611 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CID_Solar,_LLC_36.129361_-119.541797.csv",59183,246703.0,229601.28412551974,17101.71587448026 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_CID_Solar_(CA)_36.140871_-119.566235.csv,63204,12797.029999999999,18672.673682366232,-5875.643682366233 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_City_of_Tulare_Water_Facility_36.186375_-119.377771.csv,59395,12128.5,10830.724893110846,1297.775106889154 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Corcoran_Solar_2_36.141488_-119.582386.csv,59413,248087.05999999997,229978.9126016648,18108.14739833516 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Corcoran_Solar_36.142132_-119.572919.csv,58374,240450.02,232889.42761226773,7560.592387732264 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Corcoran_Solar_3_36.147519_-119.588717.csv,59900,252046.99,246740.5216734419,5306.468326558097 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Cottonwood_Solar,_LLC_(City_of_Corcoran)_36.136117_-119.558863.csv",59087,136032.03999999998,139737.42632042736,-3705.3863204273803 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Dinuba_Wastewater_Treatment_Plant_36.538178_-119.426157.csv,57827,8036.03,11531.556977094837,-3495.526977094837 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Dover_Dairy_36.41493_-119.553614.csv,65766,2004.02,2576.553019761802,-572.5330197618018 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Exeter_Solar_36.265953_-119.128349.csv,58306,32907.03,33547.20784285367,-640.1778428536709 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Farmersville_36.318418_-119.213989.csv,59203,37208.969999999994,43094.642935502714,-5885.67293550272 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_FTF-PackingShed_36.547339_-119.431282.csv,63993,2073.01,9824.534244986497,-7751.524244986496 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Guernsey_Solar_Station_36.163408_-119.650315.csv,57891,198767.01,233618.03523545188,-34851.025235451874 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Hanford_1_and_2_36.30665_-119.629057.csv,59300,28240.05,29127.793448526372,-887.743448526373 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Henrietta_Solar_Project_36.214536_-119.806731.csv,58975,1201847.0600000003,1195315.3580095468,6531.701990453526 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Ivanhoe_Solar_36.387268_-119.255203.csv,58307,32463.030000000002,33886.85960846303,-1423.829608463031 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Java_Solar,_LLC_36.231328_-119.811814.csv",65965,0.0,32303.43266879464,-32303.43266879464 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Kettleman_Solar-Centaurus_36.060918_-119.945024.csv,59633,261954.03,235721.16979820447,26232.860201795527 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Kingsburg_Solar_36.505254_-119.540118.csv,58304,34420.04,35760.328494365065,-1340.2884943650643 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Lemoore_1_36.25728_-119.797435.csv,60142,10762.02,17527.544570653892,-6765.524570653892 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Lindsay_Solar_36.211927_-119.133777.csv,58308,35524.98999999999,38117.40316744025,-2592.4131674402597 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Luciana_35.817328_-119.063026.csv,64909,98596.0,134037.8454475609,-35441.84544756089 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Mustang_Two_36.203455_-119.900562.csv,62015,795261.0,1057451.8215177984,-262190.82151779835 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Nicolis_Solar_PV_Plant_35.82219_-119.039789.csv,59600,228155.02,235452.2540503755,-7297.234050375497 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Porterville_6_and_7_36.09401_-119.037477.csv,59219,27035.039999999997,29006.265422452583,-1971.225422452586 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Porterville_Solar_36.100484_-119.038005.csv,58309,32813.020000000004,33840.33612288503,-1027.3161228850295 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_RE-VFO,_LLC_36.35362_-119.400731.csv",63455,7669.99,11434.95083135284,-3764.9608313528406 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_RE_Kansas_Solar,_LLC_36.244432_-119.829726.csv",58985,237630.06,233714.71464444595,3915.3453555540473 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_RE_Kansas_South,_LLC_36.221314_-119.829948.csv",58148,243691.05999999997,234367.91232410257,9323.147675897402 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_RE_Kent_South,_LLC_36.221972_-119.910352.csv",58991,249759.00999999998,227071.2875791209,22687.722420879087 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_RE_Mustang,_LLC_36.230414_-119.912225.csv",59150,1162398.01,1169766.9874816604,-7368.977481660433 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Sand_Drag,_LLC_35.980693_-120.102349.csv",57361,175313.00000000006,194233.99021150803,-18920.990211507975 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Slate_Hybrid_36.211961_-119.87457.csv,63727,702215.0,239270.791013349,462944.20898665104 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Solar_Photovoltaic_Project_#42_36.028665_-119.073924.csv,57441,39729.01999999999,49223.10673408966,-9494.086734089673 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Sun_City_Project,_LLC_35.985182_-120.101408.csv",57360,179956.0,204456.34887056032,-24500.348870560323 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Tropico_Solar_PV_Plant_35.831023_-119.049593.csv,59599,155728.09999999998,164265.3997214664,-8537.299721466436 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Tulare_1_and_2_36.20446_-119.417946.csv,58642,22652.009999999995,29237.565333540046,-6585.555333540051 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_Westside_Solar_Power_PV1_36.217782_-119.906783.csv,60275,24539.029999999995,23397.785264744074,1141.2447352559211 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_White_River_Solar_2_35.871483_-119.464992.csv,58973,251209.05000000002,235554.77652051934,15654.273479480675 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qdbm8_White_River_Solar_35.874844_-119.451879.csv,58373,245098.03999999998,236472.4507290981,8625.589270901866 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qe6tq_Munro_Valley_Solar_36.264822_-117.995482.csv,60412,50195.030000000006,43092.10220673625,7102.927793263756 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qe6tq_Owens_Valley_Solar_Project_11_36.268424_-117.983017.csv,60953,14280.000000000002,10771.088578253779,3508.911421746223 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qe6tq_Trona_Solar_III_35.804912_-117.349841.csv,64914,0.0,5301.394928449093,-5301.394928449093 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_AP_North_Lake_I,_LP_33.741677_-117.011471.csv",59610,195341.01,244148.59118945219,-48807.581189452176 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Arlington_Energy_Center_II_33.706592_-114.785766.csv,64481,252115.0,1160975.9940461789,-908860.9940461789 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Athos_Solar_Project_33.753074_-115.345924.csv,63300,440276.0,2528349.0038750772,-2088073.0038750772 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Blythe_Mesa_Solar_II_33.575483_-114.739432.csv,65053,32798.0,1093350.365102119,-1060552.365102119 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Blythe_Solar_110,_LLC_33.673669_-114.738061.csv",60093,1482455.02,1375588.7964327617,106866.22356723831 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Blythe_Solar_II,_LLC_33.684154_-114.739769.csv",60092,1557227.0299999998,1643596.39872124,-86369.3687212402 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Blythe_Solar_III,_LLC_Hybrid_33.659951_-114.736616.csv",60094,874839.0,1031258.9294393093,-156419.9294393093 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Blythe_Solar_IV,_LLC_33.681889_-114.769528.csv",60095,819688.0,1721535.50480909,-901847.5048090899 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Chuckawalla_Solar_33.568471_-114.917988.csv,58506,33341.03,50303.104277365564,-16962.074277365566 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Chuckawalla_Valley_State_Prison_33.565266_-114.903852.csv,57011,6952.02,9490.754552728185,-2538.734552728185 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Colgreen_North_Shore_Solar_Farm_33.547372_-115.978082.csv,60825,716886.35,906872.327879154,-189985.97787915403 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Desert_Harvest,_LLC_33.795587_-115.371453.csv",62177,491775.58,605663.5544122269,-113887.97441222687 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Desert_Harvest_II,_LLC_33.794421_-115.342448.csv",64103,399170.96,529735.3907345932,-130564.43073459313 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Desert_Hot_Springs_Solar_33.923044_-116.530143.csv,58514,28326.010000000002,27825.47211183537,500.537888164632 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Desert_Sunlight_300,_LLC_33.823568_-115.394115.csv",57993,3461380.0299999993,3313189.9104612223,148190.11953877704 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Diamond_Valley_Solar_Project_33.712238_-117.073016.csv,59405,12405.030000000002,15956.794026409354,-3551.7640264093516 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_EMWD-Moreno_Valley_RWRF_33.861247_-117.214039.csv,64406,6683.000000000001,11875.207030634447,-5192.207030634446 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_EMWD-Perris_Valley_RWRF_33.755136_-117.200101.csv,64396,10394.009999999998,17069.92090988829,-6675.910909888291 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_EMWD-San_Jacinto_RWRF_NEM_33.798117_-117.016669.csv,64397,3679.0099999999998,6315.1052625215925,-2636.0952625215928 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_EMWD-Sun_City_RWRF_33.696106_-117.218434.csv,64398,4880.990000000001,8014.316303070683,-3133.326303070682 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_EMWD_-_San_Jacinto_RES_BCT_33.803545_-117.02362.csv,64399,6743.0,20402.100206943967,-13659.100206943967 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Garnet_Solar_Generation_Station_I,_LLC_33.89107_-116.543137.csv",58528,26068.010000000002,50337.29132859589,-24269.28132859589 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Ironwood_Solar,_LLC_33.565188_-114.918553.csv",58513,35984.0,50303.980300167874,-14319.980300167874 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Maverick_Solar,_LLC_33.698716_-115.229063.csv",62178,656309.16,950628.693941317,-294319.533941317 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Maverick_Solar_4,_LLC_33.688378_-115.199522.csv",64104,614245.0,503895.7974020588,110349.20259794121 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Maverick_Solar_6,_LLC_33.74024_-115.35214.csv",64105,420247.0,504029.1634707533,-83782.1634707533 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_McCoy_Solar_Energy_Project_Hybrid_33.703743_-114.764833.csv,58462,3288351.0699999994,3389817.552285679,-101466.48228567978 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_North_Palm_Springs_1A_33.923347_-116.594548.csv,57743,24775.02,29188.839326327634,-4413.8193263276335 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_North_Palm_Springs_4A_33.908674_-116.560154.csv,57722,41938.01,48190.06891644468,-6252.058916444679 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Oberon_Solar_Project_33.725692_-115.375223.csv,65734,0.0,636131.8600900087,-636131.8600900087 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Palo_Verde_College_33.666084_-114.65691.csv,57773,10409.090000000002,14927.070313561573,-4517.980313561571 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_RCWD_PV_Project_33.536297_-117.196963.csv,60426,48306.07,48586.197796876935,-280.12779687693546 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_SE_Athos_II,_LLC_33.74373_-115.313258.csv",64290,648969.0,1001157.6431729656,-352188.6431729656 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Soboba_Community_Solar_Project_33.770206_-116.904249.csv,61834,15153.009999999998,17298.415614605838,-2145.405614605839 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Solar_Blythe,_LLC_33.591974_-114.742253.csv",56939,210443.07000000004,220320.9215728876,-9877.851572887565 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Solar_Blythe_2_33.624294_-114.699178.csv,60558,250291.97999999998,261777.35131066557,-11485.371310665592 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_SunAnza_33.557208_-116.642211.csv,60791,21790.050000000003,22554.69554112752,-764.6455411275165 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_SunEdison_Ironwood_State_Prison_33.566907_-114.918045.csv,57007,8154.040000000001,11318.291624777497,-3164.2516247774965 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Tequesquite_Landfill_Solar_PV_Project_33.97533_-117.405786.csv,60035,64623.030000000006,71846.78194136247,-7223.751941362461 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Valley_Sanitary_District_WTP_Solar_33.717775_-116.198272.csv,60824,8590.04,10294.512042164826,-1704.4720421648253 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Venable_Solar_1_33.598564_-114.571681.csv,58289,14929.01,15426.121370219827,-497.1113702198272 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qj152_Venable_Solar_2_33.597048_-114.571952.csv,58290,14939.04,15426.171861844443,-487.131861844442 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_Black_Mountain_Solar,_LLC_35.022825_-114.162449.csv",58042,103689.99,113790.866720077,-10100.876720076994 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_Gray_Hawk_Solar_35.349159_-113.914259.csv,61272,635763.0,582253.3999594245,53509.60004057549 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_Jacobson_5_MW_Solar_35.303874_-114.01518.csv,60603,44786.00000000001,47844.69203992595,-3058.6920399259398 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_La_Senita_35.241588_-114.004585.csv,57556,9850.040000000003,12685.093955387578,-2835.053955387575 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_Mohave_Electric_at_Fort_Mohave_34.983955_-114.55634.csv,59819,78710.03000000001,45834.35877224012,32875.67122775989 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qndpr_Mohave_Electric_Cooperative_at_Joy_Lane_34.994777_-114.553771.csv,63554,99399.01999999999,124782.85670306125,-25383.836703061257 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Apex_Solar_PV_Power_Project_36.392197_-114.964727.csv,58489,258552.03000000003,252414.6735532984,6137.356446701626 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Boulder_Solar_II,_LLC_35.84781_-114.945912.csv",60885,662586.0,614764.1957923317,47821.80420766829 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Boulder_Solar_Power,_LLC_35.836256_-114.9816.csv",60352,1357633.0,1231109.212816151,126523.78718384891 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_CM10_35.786467_-114.997984.csv,56944,101744.04000000001,105677.17406876716,-3933.1340687671473 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_CM48_35.781022_-114.992615.csv,57205,490918.05,507255.1130247579,-16337.063024757896 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Copper_Mountain_Solar_2_35.785768_-114.961632.csv,58017,1818973.03,1627454.1771299469,191518.85287005315 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Copper_Mountain_Solar_3_35.881832_-114.965487.csv,58915,3057374.0,2629740.8745904868,427633.12540951325 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Copper_Mountain_Solar_4,_LLC_35.788794_-114.979682.csv",59814,1281076.0199999998,1154811.6521876259,126264.36781237391 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Copper_Mountain_Solar_5,_LLC_35.771769_-114.976657.csv",63504,1040005.0,1229664.1403604303,-189659.14036043035 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Harry_Allen_Solar_Energy,_LLC_36.425518_-114.923188.csv",63080,471369.0,491984.82474222215,-20615.824742222147 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Las_Vegas_WPCF_Solar_Plant_36.134709_-115.03527.csv,58477,31875.220000000005,40919.477676544055,-9044.25767654405 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Moapa_Southern_Paiute_36.525935_-114.75462.csv,57859,3096586.0,2690639.18384721,405946.8161527901 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Mountain_View_Solar_36.386503_-114.952156.csv,58544,270682.00999999995,251046.93498260563,19635.075017394323 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Nellis_Air_Force_Base_Solar_Array_36.256491_-115.054411.csv,56568,117498.0,160828.55772950777,-43330.55772950777 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Nellis_Solar_PV_II_36.207622_-115.04642.csv,59919,195640.0,190745.3035376814,4894.696462318592 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Playa_Solar_1,_LLC_36.400079_-114.901877.csv",59827,1049830.0,971315.8903537302,78514.10964626982 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Playa_Solar_2_36.410661_-114.912141.csv,60261,1441901.0,1229434.1676381235,212466.8323618765 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_River_Mountains_Solar_36.031854_-114.927786.csv,59747,154452.04,180807.1452418506,-26355.1052418506 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Searchlight_Solar_35.486403_-114.934023.csv,59404,238261.03,224940.0959312715,13320.9340687285 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Silver_State_Solar_Power_North_35.62505_-115.350152.csv,57442,582516.01,568086.5348565663,14429.475143433665 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Silver_State_Solar_Power_South_35.607882_-115.337278.csv,58644,3354534.02,3209024.7597006275,145509.2602993725 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Spectrum_Solar_PV_Power_Project_36.23712_-114.87362.csv,58490,415696.02,371945.12977767154,43750.89022232848 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Techren_Solar_I,_LLC_35.852813_-114.968555.csv",61611,935039.0,992714.9335064208,-57675.93350642081 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Techren_Solar_II,_LLC_35.867654_-114.955521.csv",61930,1817079.0,1985261.751763396,-168182.75176339597 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Techren_Solar_III,_LLC_35.844998_-114.972093.csv",61931,147716.0,187082.28439350528,-39366.28439350528 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Techren_Solar_IV,_LLC_35.892361_-114.936029.csv",61932,144650.0,185671.70001266844,-41021.70001266844 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Techren_Solar_V_35.901334_-114.926483.csv,62440,277123.0,371322.91909091227,-94199.91909091227 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qqk6u_Townsite_Solar_Project_Hybrid_35.938777_-114.886585.csv,60654,499509.0,791444.1309103038,-291935.1309103038 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qw0kp_Bloomington_Solar_I_37.043952_-113.627719.csv,62805,16929.0,20491.109786119177,-3562.1097861191774 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qw0kp_NVSS-II_36.275343_-115.972339.csv,62636,101358.03,151943.96162754536,-50585.93162754536 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9qw0kp_Sunshine_Valley_Solar_36.515032_-116.515336.csv,59826,647754.0,1011903.0509098301,-364149.05090983014 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r106e_Enerparc_CA2,_LLC_39.69908_-122.175386.csv",59978,17245.030000000002,16726.34972709335,518.6802729066512 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r13pb_Butte_College_Main_Campus_Solar_39.651561_-121.650012.csv,57970,29708.039999999997,33005.5779154348,-3297.537915434801 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r13pb_Gridley_Main_39.373372_-121.684357.csv,58370,8331.05,11183.587303424527,-2852.5373034245276 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r13pb_Gridley_Main_Two_39.373289_-121.681455.csv,58371,20078.019999999997,27958.9189132429,-7880.8989132429015 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r1jcf_Shasta_Solar_Farm_41.031259_-121.425306.csv,58814,35715.03,33991.3809029987,1723.6490970012965 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r1jcf_Sierra_Pacific_Industries_(2042-RD)_40.122194_-122.189406.csv,63416,48384.01000000001,48181.95775051281,202.05224948719842 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Bly_Solar_Center_42.37664_-121.020118.csv,62272,80410.03,88082.9442576255,-7672.914257625496 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Chiloquin_Solar,_LLC_42.611487_-121.862597.csv",61631,99876.02,95645.67915444168,4230.340845558327 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Klamath_Falls_Solar_2_(CSG)_42.182954_-121.763455.csv,61553,32626.019999999997,32574.11362868309,51.90637131690528 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_NorWest_Energy_4,_LLC_42.207084_-121.351576.csv",62268,43469.009999999995,50540.56471431093,-7071.554714310936 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Old_Mill_Solar_42.408186_-121.043107.csv,59374,53043.06,54823.08423099706,-1780.0242309970636 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Oregon_University_System_OIT_Klamath_Falls_42.260185_-121.785776.csv,58961,12734.99,18250.977149180384,-5515.987149180384 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_OR_Solar_3,_LLC_42.022228_-121.425629.csv",61201,121936.04,111926.96166387292,10009.078336127073 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_OR_Solar_5,_LLC_42.031034_-121.611061.csv",61423,96986.99999999999,89661.27159104188,7325.728408958108 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_OR_Solar_8,_LLC_42.239049_-121.58562.csv",61424,126763.04999999999,111972.20529351506,14790.844706484932 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r3wzq_Woodline_Solar_42.236037_-121.577258.csv,61559,87219.02,89890.59584376946,-2671.5758437694603 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_Fish_Springs_40.080627_-119.963667.csv,64148,223573.0,458091.90851469134,-234518.90851469134 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_HL_Solar_40.372677_-120.264829.csv,62655,34376.020000000004,70304.82360841388,-35928.80360841387 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_PSREC_SIAD_Solar_40.150274_-120.124711.csv,63493,19224.99,27919.88508568195,-8694.89508568195 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_Turquoise_Liberty_Solar_39.580532_-119.517431.csv,62980,64233.01,95137.1553403816,-30904.145340381605 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_Turquoise_Nevada,_LLC_39.587008_-119.527319.csv",63906,222230.0,350406.0430246057,-128176.04302460572 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r4bc7_Western_102_Power_Plant_39.560389_-119.509091.csv,56500,11184.0,10104.013624885034,1079.986375114966 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_EGP_Stillwater_Solar_PV_II,_LLC_39.537086_-118.563667.csv",61809,107653.05999999997,207286.97749472116,-99633.91749472119 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_Ft._Churchill_PV_39.121494_-119.140914.csv,59472,164884.03000000006,214784.70167757027,-49900.67167757021 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_Luning_Energy_38.545208_-118.193732.csv,61084,653190.0,597697.4818677454,55492.5181322546 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_Patua_Acquisition_Project,_LLC_39.582548_-119.068946.csv",58319,133672.05000000002,125548.94718111333,8123.102818886691 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_Stillwater_Facility_39.542771_-118.560936.csv,50765,196820.01,214661.97099009363,-17841.96099009362 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r50xy_Tungsten_Mountain_39.666486_-117.681253.csv,60785,59832.0,71772.20669608456,-11940.206696084555 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r88yx_Eagle_Point_Solar_42.400782_-122.830308.csv,61560,86565.07,99858.38751759504,-13293.317517595031 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r88yx_OR_Solar_2,_LLC_42.521494_-122.828455.csv",61200,43692.01999999999,61085.38927241046,-17393.36927241047 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Airport_Solar_42.166668_-120.409479.csv,62560,321640.0,420136.5338023121,-98496.5338023121 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Alkali_Solar,_LLC_43.31856_-121.002206.csv",63795,65984.04000000001,65884.86067318192,99.1793268180918 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_BC_Solar_42.172667_-120.362524.csv,60616,91497.05,88071.29933629528,3425.750663704719 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Black_Cap_Solar_Plant_42.175092_-120.362663.csv,58150,18120.99,22017.524770187436,-3896.5347701874343 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Fort_Rock_IV_43.397002_-120.948912.csv,63926,59171.009999999995,65804.71552713479,-6633.705527134793 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Fort_Rock_I_43.316651_-121.00914.csv,63636,70684.98000000001,65226.70930818541,5458.2706918146 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Garrett_Solar_42.147793_-120.420207.csv,63301,73819.05000000002,89033.2835274218,-15214.233527421777 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_OR_Solar_6,_LLC_42.211172_-120.371519.csv",61430,122205.03000000001,109975.07102625871,12229.958973741304 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Outback_Solar_at_Christmas_Valley_43.235275_-120.486327.csv,58131,48879.01000000001,48126.6990058974,752.3109941026123 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9r9uxw_Rock_Garden_Solar,_LLC_43.394159_-120.954844.csv",63779,63372.01,65805.89492080032,-2433.8849208003157 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Baldock_Solar_Highway_45.269653_-122.771784.csv,57882,9512.030000000002,12472.936920697422,-2960.90692069742 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Ballston_Solar,_LLC_45.076462_-123.394093.csv",62170,14902.039999999999,16700.801908805995,-1798.7619088059964 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Bellevue_Solar_Project_45.112295_-123.234291.csv,57372,4877.04,10098.513623478979,-5221.473623478979 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Bighorn_Solar_44.967035_-122.957862.csv,63467,6587.0,11603.651853892981,-5016.651853892981 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Boring_Solar,_LLC_45.430769_-122.28454.csv",62169,14862.04,12209.211199165393,2652.828800834608 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Brightwood_Solar,_LLC_45.383402_-122.079111.csv",64830,11326.01,27461.159017139846,-16135.149017139845 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Bristol_Solar_45.144867_-122.786688.csv,64009,8613.02,8923.533163536824,-310.5131635368234 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Brush_Creek_Solar_44.985426_-122.812712.csv,63464,8680.04,11466.729416063115,-2786.6894160631145 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Butler_Solar,_LLC_45.101472_-123.41943.csv",63694,16332.01,14342.414154852433,1989.5958451475672 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Carnes_Creek_Solar_(CSG)_45.076112_-122.933266.csv,65745,83.0,4236.419039875971,-4153.419039875971 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Case_Creek_Solar_45.172331_-122.912379.csv,63207,11956.06,13171.305329261904,-1215.2453292619048 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Colton_Solar_45.170298_-122.472865.csv,61831,16153.049999999997,15389.17424114668,763.8757588533172 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Cosper_Creek_Solar_(CSG)_45.058885_-123.497377.csv,65746,94.0,4343.543812317391,-4249.543812317391 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Dayton_Cutoff_Solar_45.169611_-123.13626.csv,61827,18069.07,16281.408394166925,1787.6616058330746 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Day_Hill_Solar,_LLC_45.268845_-122.329109.csv",63957,7771.010000000001,9757.535909098835,-1986.5259090988338 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Drift_Creek_Solar_44.970522_-122.802471.csv,63466,9211.029999999999,10010.177017735346,-799.1470177353476 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Dunn_Road_Solar_45.431494_-122.286481.csv,63642,6342.990000000001,5807.2629600010705,535.7270399989302 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Duus_Solar,_LLC_45.318494_-122.331678.csv",63330,54717.030000000006,48690.84024129017,6026.189758709836 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Firwood_Solar,_LLC_45.379532_-122.229859.csv",63331,55598.00000000001,48563.956053929236,7034.043946070771 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Fruitland_Creek_Solar_(CSG)_44.929836_-122.937619.csv,65747,57.0,3033.0424258211897,-2976.0424258211897 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Grand_Ronde_Solar_45.053049_-123.609457.csv,61835,21141.019999999997,16245.304373961977,4895.71562603802 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Greenpark_Solar_44.876176_-122.935312.csv,64033,4048.01,5965.839266695372,-1917.829266695372 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Interstate_Solar_45.129636_-122.899589.csv,61832,19764.0,16793.855109594897,2970.144890405103 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Kaiser_Creek_Solar_(CSG)_45.143578_-122.607851.csv,65748,63.0,3296.0744927209257,-3233.0744927209257 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Kale_Patch_Solar_45.083174_-122.90282.csv,63208,12046.020000000002,13212.200921490003,-1166.1809214900004 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Labish_Solar,_LLC_44.985089_-122.941138.csv",62171,15563.02,16495.82049601898,-932.8004960189792 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Milford_Solar_OR_45.559908_-123.071525.csv,64008,9212.02,8950.56983106184,261.45016893815955 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Mill_Creek_Solar_(OR)_45.168553_-123.135107.csv,61338,19643.980000000003,16281.474219121312,3362.5057808786914 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Minke_Solar_45.171211_-122.624282.csv,63465,6145.03,11219.07165635219,-5074.041656352189 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Mt._Hope_Solar_45.126464_-122.608112.csv,63663,8463.02,8477.115159820612,-14.095159820612025 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_O'Neill_Creek_Solar_45.471659_-123.13974.csv,63235,11863.02,13197.23289583353,-1334.2128958335288 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Oregon_University_System_Rabbit_Field_44.566239_-123.295743.csv,59790,6690.0199999999995,9188.317541669634,-2498.2975416696345 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Palmer_Creek_Solar,_LLC_45.184296_-123.103751.csv",63956,8118.01,10684.120973971741,-2566.1109739717413 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Pika_Solar_45.088004_-122.772281.csv,63462,7137.0199999999995,11481.998645856096,-4344.978645856097 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Rafael_Solar_44.859872_-123.008155.csv,63206,12055.01,13215.74733978175,-1160.73733978175 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Red_Prairie_Solar_45.086377_-123.422801.csv,65228,4651.01,6732.133183770508,-2081.123183770508 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_River_Valley_Solar_45.128043_-122.828527.csv,63665,1470.0,9865.920439426487,-8395.920439426487 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sandy_River_Solar_(CSG)_45.43149_-122.295791.csv,65750,103.0,2976.6950504558386,-2873.6950504558386 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sheep_Solar_44.827488_-122.948339.csv,61830,19147.05,16936.07617182259,2210.973828177408 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Silverton_Solar_45.014302_-122.807152.csv,61829,18928.05,16587.340254515835,2340.709745484164 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Clackamas_1,_LLC_45.420938_-122.333268.csv",63961,10225.02,19452.085228836255,-9227.065228836254 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Clackamas_4,_LLC_45.105651_-122.662012.csv",63962,7567.0,10330.057678950432,-2763.057678950432 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Clackamas_7,_LLC_45.181767_-122.591971.csv",63963,6716.029999999999,10198.579784397047,-3482.549784397048 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Marion_1,_LLC_45.137896_-122.914407.csv",63964,7563.030000000001,10565.514027251438,-3002.4840272514375 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Marion_3,_LLC_44.984203_-122.960193.csv",63958,6951.02,10665.572198941745,-3714.552198941745 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Marion_5,_LLC_45.113431_-122.793289.csv",63959,7367.0199999999995,10436.888965523132,-3069.868965523133 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_SSD_Marion_6,_LLC_45.255099_-122.803325.csv",63960,7790.049999999999,10370.115503768438,-2580.065503768439 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Steel_Bridge_Solar,_LLC_45.067675_-123.470971.csv",60057,16141.01,17600.930211249008,-1459.9202112490075 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_St_Louis_Solar_45.120234_-122.936268.csv,63456,11436.01,11623.029322426548,-187.01932242654766 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_17_45.349163_-122.429474.csv,63908,11257.029999999997,13356.009715425344,-2098.9797154253465 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_22_44.974004_-122.776207.csv,64022,8291.01,8964.363504530684,-673.3535045306835 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_25_45.268993_-122.82176.csv,64034,6839.060000000001,9879.601712695727,-3040.5417126957254 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_28_45.103864_-123.515506.csv,64007,10129.98,13870.85889890608,-3740.8788989060813 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_29_45.458507_-122.289444.csv,64048,7347.029999999999,11015.889370412111,-3668.859370412112 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_33_45.079018_-123.40303.csv,64006,9505.98,9180.325357210624,325.65464278937543 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Sulus_Solar_35_45.141533_-122.649541.csv,63969,11356.01,13352.122463317446,-1996.1124633174459 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Thomas_Creek_Solar_45.131375_-122.619444.csv,63443,11559.99,14924.850450334008,-3364.8604503340084 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Tickle_Creek_Solar_45.3733_-122.264946.csv,63442,9068.01,12339.148134178118,-3271.138134178118 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Valley_Creek_Solar_45.03301_-123.09691.csv,61828,19562.04,16615.81007177665,2946.2299282233507 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Williams_Acres_Solar_45.137367_-122.800157.csv,63664,7856.03,8659.557174602716,-803.5271746027165 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rb6wg_Yamhill_Solar,_LLC_45.10838_-123.278175.csv",57652,4580.05,7824.508396148786,-3244.458396148786 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_Adams_Solar_Center_44.673117_-121.125151.csv,61496,100952.03,102807.29252327776,-1855.2625232777646 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_Bear_Creek_Solar_Center_44.06044_-121.238169.csv,61281,99015.01000000001,107196.13243196423,-8181.122431964221 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_Elbe_Solar_Center_44.61898_-121.206217.csv,61497,99859.02,104583.37822996746,-4724.35822996746 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_NorWest_Energy_2,_LLC_44.068482_-121.228347.csv",60548,107298.01999999999,105240.04501597476,2057.9749840252334 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_OSLH,_LLC_44.059598_-121.229434.csv",60976,110867.03,106124.91044358972,4742.119556410282 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_Solar_Star_Oregon_II_44.185237_-120.916008.csv,61048,610320.0,587170.0134424927,23149.986557507305 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rcvn1_Tumbleweed_Solar,_LLC_44.19398_-121.23007.csv",61580,100246.03000000001,91788.40678714498,8457.623212855033 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Baker_City_Solar_44.7018_-117.763861.csv,61854,95847.02,92070.72000556994,3776.299994430068 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Brush_Solar_Center_44.466797_-118.205391.csv,61844,18836.04,17092.528721772745,1743.5112782272554 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Grove_Solar_Center,_LLC_43.936046_-117.384902.csv",60330,66589.01000000001,61572.67027649748,5016.339723502526 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Hyline_Solar_Center,_LLC_44.150366_-117.000996.csv",60331,95259.01999999999,92128.77212396155,3130.24787603844 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Morgan_Solar_Center_43.950218_-117.072991.csv,61855,19099.97,18598.337933184648,501.632066815353 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Murphy_Flat_Solar_43.211407_-116.441859.csv,60009,219939.01999999996,210961.3774791824,8977.64252081755 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Ontario_Solar_Center_44.113233_-117.026613.csv,61860,19536.02,18546.22828039819,989.7917196018097 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Open_Range_Solar_Center,_LLC_43.796958_-117.06293.csv",60332,113350.01,101883.12057310886,11466.889426891139 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Railroad_Solar_Center,_LLC_43.999105_-117.100477.csv",60333,50801.990000000005,46032.08580152366,4769.904198476346 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Riley_43.554283_-119.684458.csv,63925,58965.00000000001,65508.90853495677,-6543.908534956761 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Starvation_43.503691_-119.149256.csv,63344,70857.01999999999,86450.66434967819,-15593.644349678201 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Suntex_Solar,_LLC_43.552737_-119.689962.csv",63778,62615.020000000004,65509.67926424217,-2894.6592642421674 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Thunderegg_Solar_Center,_LLC_43.932783_-116.988348.csv",60334,111362.0,102510.79685358587,8851.203146414133 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Vale_Air_Solar_Center,_LLC_43.961698_-117.259276.csv",60335,110450.03,102416.72272432213,8033.307275677871 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_Vale_Solar_Center_44.158147_-117.443681.csv,61856,14415.009999999998,16227.473012427907,-1812.4630124279083 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rg8bx_West_Hines_Solar_I,_LLC_43.499962_-119.146275.csv",63796,63130.000000000015,65427.17007558465,-2297.1700755846323 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rkf69_Battle_Mountain_Solar_Project_40.720895_-117.063807.csv,61098,463312.0,457387.14810990106,5924.851890098944 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rpbwn_Pavant_Solar,_LLC_39.151744_-112.343248.csv",59702,552180.01,564715.7591903153,-12535.749190315255 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rpbwn_Pavant_Solar_II,_LLC_39.158924_-112.353087.csv",60449,595665.0400000002,568197.2240034251,27467.815996575053 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rpbwn_Pavant_Solar_III_39.157077_-112.373955.csv,60886,243088.04000000004,227281.95161512625,15806.088384873787 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Clif_Bar_Bakery_of_Twin_Falls_42.5382_-114.410983.csv,62151,9948.02,15021.85007458654,-5073.83007458654 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Grand_View_Solar_Two_43.015967_-116.015811.csv,60068,914933.0,848935.0237851711,65997.9762148289 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_ID_Solar_43.440923_-116.32853.csv,60445,473835.04,425187.90294899023,48647.13705100975 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Jackpot_Solar,_LLC_42.200942_-114.630973.csv",65778,4557.0,252188.05177946502,-247631.05177946502 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Mt._Home_Solar_1,_LLC_43.147282_-115.721926.csv",59695,238388.02,216468.37825164193,21919.64174835806 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Orchard_Ranch_Solar_43.468911_-116.289494.csv,60010,234095.01,212557.62417886997,21537.38582113004 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rwgcr_Simcoe_Solar_43.325088_-115.939035.csv,60748,238385.01,215054.66518900005,23330.34481099996 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rx7st_American_Falls_Solar_42.830953_-112.742728.csv,60011,218341.99000000002,207815.65414120085,10526.335858799168 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9rx7st_American_Falls_Solar_II_42.825716_-112.749122.csv,60012,224169.02,207822.16085814981,16346.859141850175 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Arlington_Valley_Solar_Energy_II_33.298671_-112.827225.csv,57680,1752878.01,1569680.5743783363,183197.4356216637 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Avalon_Solar_32.03087_-110.958585.csv,59168,371969.9799999999,363398.55731533194,8571.422684667981 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Avalon_Solar_II_32.042663_-110.959069.csv,60062,218020.02000000002,200483.23945024656,17536.780549753457 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Badger_1_33.49817_-112.813276.csv,58262,194857.03999999998,182766.99364653372,12090.046353466256 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Bonnybrooke_PV_33.051117_-111.340769.csv,60413,685717.0399999999,613496.7352131612,72220.30478683871 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Broadway_2_-_Tucson_Phase_II_32.242474_-111.258304.csv,64580,5054.02,7554.894430524038,-2500.874430524038 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Buckeye_Union_HS_District_201_33.417858_-112.574539.csv,58037,35374.03999999999,31901.90806055093,3472.131939449064 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Chino_Solar_Valley_34.724115_-112.432264.csv,57560,233246.05999999997,237684.70375195568,-4438.643751955708 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Cogenra-TEP_32.101847_-110.813116.csv,58832,9903.0,12444.702435785284,-2541.7024357852843 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Cotton_Center_Solar_Hybrid_33.034607_-112.661625.csv,57561,190627.05,208930.00626733602,-18302.956267336034 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Davis_Monthan_AFB_(AZ)_West_Airfield_32.170516_-110.897011.csv,59779,119173.99999999999,156582.80690156852,-37408.80690156853 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Desert_Star_Hybrid_33.144218_-112.661591.csv,59444,155666.02000000002,137496.1479950835,18169.872004916513 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_East_Line_Solar_32.831954_-111.573906.csv,62899,480036.0,745661.430977311,-265625.430977311 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_FRB_Solar_Farm_32.107057_-110.824225.csv,57930,3618.02,23644.1894270743,-20026.1694270743 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Gato_Montes_Solar,_LLC_32.105004_-110.822521.csv",58842,41771.060000000005,52146.77362427013,-10375.713624270124 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Gila_Bend_Hybrid_32.948588_-112.769774.csv,59020,457164.05,457222.14214438066,-58.092144380672835 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Gilbert_Solar_Facility_I,_LLC_33.356339_-111.803663.csv",58543,17190.04,30346.381221001513,-13156.341221001512 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Iron_Horse_Battery_Storage_Hybrid_32.101778_-110.819001.csv,60996,12192.0,16918.10496503643,-4726.104965036429 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Lake_Pleasant_WTP_33.82314_-112.24089.csv,58539,73837.06000000003,73632.17172292557,204.88827707445307 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Luke_Solar_33.52506_-112.382458.csv,57324,126620.03,137226.09115289862,-10606.06115289862 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Mesa_Solar_Array_33.345243_-111.601785.csv,58466,0.0,41852.869066138715,-41852.869066138715 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Mesquite_Solar_1_33.345446_-112.923848.csv,57707,2058848.03,1760888.1658751187,297959.86412488134 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Mesquite_Solar_2,_LLC_33.331271_-112.923389.csv",60307,1314853.0,1239317.5784734879,75535.42152651213 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Mesquite_Solar_3,_LLC_33.340897_-112.950747.csv",60308,2235337.0,1904740.5460085433,330596.45399145666 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Mesquite_Solar_5,_LLC_33.355906_-112.915082.csv",65963,0.0,149247.86773369607,-149247.86773369607 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Paloma_Solar_Hybrid_33.020959_-112.661797.csv,57562,188804.00999999998,183334.9514302386,5469.0585697613715 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Picture_Rocks_Solar,_LLC_32.370827_-111.238244.csv",58486,260783.03999999998,246785.83964788326,13997.20035211672 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Pinal_Central_Energy_Center_Hybrid_32.875696_-111.546455.csv,61678,298479.33,247180.81772706413,51298.512272935885 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Poseidon_Solar,_LLC_33.158993_-111.481623.csv",57318,257950.04,243927.09900649905,14022.94099350096 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Prairie_Fire_32.117216_-110.819418.csv,58171,41365.02,47574.63565081347,-6209.615650813474 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Prescott_Airport_34.677792_-112.40593.csv,56228,24623.010000000002,36974.72389287058,-12351.713892870575 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Prescott_Solar_Plant_34.689322_-112.402614.csv,58147,108601.02999999998,130178.86469352523,-21577.83469352525 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Queen_Creek_Solar_Farm_33.268352_-111.613368.csv,57883,237266.04,232115.48939589394,5150.550604106073 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Raptor_Ridge_32.141669_-110.883906.csv,65972,18601.02,31379.172520141765,-12778.152520141764 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Red_Rock_32.554828_-111.280849.csv,60467,575504.0,497047.5255534377,78456.4744465623 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_RE_Ajo_1,_LLC_32.365016_-112.831304.csv",57795,42682.01,56726.84805461576,-14044.838054615757 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_RE_Bagdad_Solar_I,_LLC_34.587837_-113.175721.csv",57790,153281.03999999998,187291.16412988096,-34010.12412988098 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Rio_Rico_Solar_31.494163_-111.006063.csv,59044,52128.03,63313.98738919213,-11185.957389192132 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Roger_Road_WWTP_32.289889_-111.032982.csv,57524,5526.039999999999,11132.991856376228,-5606.9518563762285 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Saddle_Mountain_Solar_I_33.381248_-113.18452.csv,58213,172676.05,187700.28368894165,-15024.233688941662 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Saint_Solar_32.85423_-111.502706.csv,63476,594427.0,494542.4966629566,99884.5033370434 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Sandstone_Solar_33.041452_-111.451962.csv,59634,605101.04,552045.1352297945,53055.904770205496 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Sun_Streams,_LLC_33.354277_-112.839341.csv",60827,1207269.0,1167062.7578759824,40206.24212401756 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Sun_Streams_2_33.319211_-112.816655.csv,63440,644924.0,731145.9883324167,-86221.98833241675 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Tech_Park_Solar_32.099647_-110.81571.csv,59455,67209.09,47188.026871322465,20021.06312867753 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_UASTP_I_32.099521_-110.811275.csv,57392,9643.02,14933.835725333389,-5290.815725333388 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Valencia_Solar_32.145812_-110.87957.csv,59454,129209.06,112100.38345328573,17108.67654671427 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Walmart_Casa_Grande_32.868853_-111.771846.csv,57939,10781.029999999999,24785.157302372718,-14004.127302372719 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w01f3_Wilmot_Energy_Center,_LLC_32.034942_-110.898385.csv",64426,482850.0,652357.9248128071,-169507.92481280712 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Apache_Solar_1_32.068285_-109.888694.csv,60964,265367.08,256777.51396575655,8589.566034243471 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Fort_Huachuca_Solar_PV_Project_31.555551_-110.320155.csv,58972,193219.04,190581.78239437498,2637.2576056250255 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Kayenta_Solar_Project_36.787247_-110.2405.csv,61268,439146.0,557360.9877437698,-118214.98774376977 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Red_Horse_2_32.257451_-110.156832.csv,58833,760801.0,698326.7106747689,62474.289325231104 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Red_Horse_III_32.268153_-110.151375.csv,60285,380826.01,382636.3903819918,-1810.3803819917957 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1wf0_Sulphur_Springs_32.066676_-109.921281.csv,60381,267337.04,263197.25686345925,4139.783136540733 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Alamogordo_Solar_Energy_Center_32.866111_-106.000164.csv,57577,55572.02999999999,51885.25137351429,3686.7786264856986 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Alta_Luna_32.569775_-107.468255.csv,60258,350993.0,359508.13895438553,-8515.138954385533 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_City_of_Truth_or_Consequences_PV_33.12037_-107.290215.csv,59653,18013.030000000002,23740.52753615076,-5727.497536150757 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Columbus_Solar_Project_31.867725_-107.589071.csv,61165,25432.020000000004,24474.60463921786,957.4153607821427 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Deming_Solar_Energy_Center_32.168645_-107.755631.csv,57575,98148.04000000001,98291.93837353452,-143.89837353451003 +C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Fort_Bliss_(DEA_EPIC)_31.830723_-106.37295.csv,61887,19339.03,20757.99760155062,-1418.967601550623 +"C:/Users/kperry/Documents/extreme-weather-ca-heatwave\pvwatts_powerplants\9w1zzg_Hatch_Solar_Energy_Center_I,_LLC_32.628623_-107.259863.csv",57591,61467.01,64058.04143516779,-2591.031435167788 diff --git a/data/run_pvwatts.py b/data/run_pvwatts.py index c79997f9..4c3f8ea4 100644 --- a/data/run_pvwatts.py +++ b/data/run_pvwatts.py @@ -9,7 +9,7 @@ import pvlib from pvlib.temperature import TEMPERATURE_MODEL_PARAMETERS from matplotlib import pyplot as plt -from utils import geohash, nsrdb_weather +from utils import geohash, nsrdb_credentials import glob def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, @@ -77,9 +77,9 @@ def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, # Get the geohash associated with the site system_identifier = (bus + "_" + name + "_" + str(lat) + "_" + str(long)).replace(" ", "_").replace("/", "_") - if system_identifier + ".csv" in already_run: - print("already run!!") - continue + # if system_identifier + ".csv" in already_run: + # print("already run!!") + # continue geohash_val = geohash(lat, long, precision=6) # convert to KW power = row['capacity[MW]'] * 1000 @@ -96,9 +96,9 @@ def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, tilt = 0 else: tilt = 20 - # Skip the system if it went online after 2022 - if int(row['year']) > 2022: - continue + # # Skip the system if it went online after 2022 + # if int(row['year']) > 2022: + # continue # Otherwise, start at 2018 or, if later, when the system came online if int(row['year']) > 2018: min_measured_date = pd.to_datetime(str(int(row['year'])) + "-01-01 00:00:00") @@ -108,17 +108,26 @@ def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, print(min_measured_date, max_measured_date) # Pull the site's associated NSRDB data master_weather_df = pd.DataFrame() + nsrdb_creds = nsrdb_credentials() for year in range(min_measured_date.year, max_measured_date.year): for try_time in range(0,3): try: - df = nsrdb_weather(geohash_val, - year, - interval=30, - attributes={'Temperature': 'temp_air', - 'DHI': 'dhi', - 'DNI': 'dni', - 'GHI': 'ghi', - 'Wind Speed': 'wind_speed'}) + attributes={'temp_air': "Temperature", + 'dhi': "DHI", + 'dni': "DNI", + 'ghi': "GHI", + 'wind_speed': 'Wind Speed'} + fields = list(attributes.keys()) + df, headers = pvlib.iotools.get_nsrdb_psm4_aggregated(latitude=lat, + longitude=long, + parameters=fields, + api_key=nsrdb_creds[1], + email=nsrdb_creds[0], + year = year, + leap_day=True, + full_name="Kirsten Perry", + affiliation="NREL") + df = df.rename(columns =attributes) master_weather_df = pd.concat([master_weather_df, df]) break except: diff --git a/data/utils.py b/data/utils.py index 00baf988..6b2bbfee 100644 --- a/data/utils.py +++ b/data/utils.py @@ -240,7 +240,7 @@ def nsrdb_weather(location,year, leap = (year%4 == 0) email, api_key = nsrdb_credentials() # Pull from API and save locally - psm3, _ = pvlib_psm3.get_psm3(lat, lon, + psm3, _ = pvlib.get_psm3(lat, lon, api_key, email, year, attributes=attributes.values(), From 3f5410e80f88ffaa18a0447d63213f6645889fcb Mon Sep 17 00:00:00 2001 From: kperry Date: Wed, 29 Apr 2026 09:14:15 -0600 Subject: [PATCH 13/17] added new slurm setup, tested, and running --- data/generate_herbie_forecasts.py | 213 +- data/generate_herbie_forecasts_local.py | 227 - data/generate_herbie_forecasts_slurm.py | 238 - data/slurm/slurm.sh | 21 + data/slurm_outputs/herbie_13573894.err | 32442 ++++++++++++++++++++++ 5 files changed, 32576 insertions(+), 565 deletions(-) delete mode 100644 data/generate_herbie_forecasts_local.py delete mode 100644 data/generate_herbie_forecasts_slurm.py create mode 100644 data/slurm/slurm.sh create mode 100644 data/slurm_outputs/herbie_13573894.err diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 98672e19..670e4c97 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -95,102 +95,99 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): return @delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): +def pull_herbie_gefs_data(date, time_horizon, aws_profile): """ Similar function for Herbie GEFS data. """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df + for i in range(3): + try: + logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") + H = Herbie(date, + model="gefs", + fxx=time_horizon, + product="atmos.5b", + member="p01", + ) + file = H.download() + tags = ["UGRD:80 m", + "VGRD:80 m", + "TCDC", + "TMP:surface", + "DPT:2 m"] + specific_tag_names = [":TCDC:475 mb:", + ":UGRD:80 m above ground:", + ":VGRD:80 m above ground:", + "TMP:surface:", + "DPT:2 m above ground:"] + master_pred_df= pd.DataFrame() + for tag in tags: + tag_df=H.inventory(tag) + tag_df = tag_df.reset_index(drop=True) + tag_match = [x for x in specific_tag_names if + tag_df['variable'].iloc[0] in x][0] + index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name + ds = H.xarray(tag, remove_grib=True) + if isinstance(ds, list): + ds = ds[int(index_val)] + predictions = list() + for point in points: + if "d2m" in ds: + pred = ds['d2m'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "tcc" in ds: + pred = ds['tcc'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "u" in ds: + pred = ds['u'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "v" in ds: + pred = ds['v'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "r2" in ds: + pred = ds['r2'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "sp" in ds: + pred = ds['sp'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + elif "t" in ds: + pred = ds['t'].sel(longitude=point[0], + latitude=point[1], + method='nearest').values.reshape(1) + else: + break + predictions.append(pred) + predictions = list(np.concatenate(predictions)) + pred_df = pd.DataFrame() + pred_df['longitude'] = [point[0] for point in points] + pred_df['latitude'] = [point[1] for point in points] + pred_df['forecast_time'] = date + pred_df['time_horizon_hrs'] = time_horizon + pred_df['tag'] = tag + pred_df['value'] = predictions + master_pred_df = pd.concat([master_pred_df, pred_df]) + master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + + date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", + index=False, + storage_options=aws_profile) + # Delete the file in question (to save storage space) + os.remove(file) + except Exception as e: + print(e) + logger.info(e) + time.sleep(5) # backoff + logger.info("Download failed for {date} {time_horizon} hr time horizon...") + return forecast_dir = "C:/Users/kperry/data/" if __name__ == "__main__": - # Declare SLURM Cluster - cluster = SLURMCluster( - cores=18, - memory='24GB', - account='pvfleets24', - walltime='00:30:00', - processes=17, - queue='shared' - ) # Connect to the db and get the associated AWS creds pvr = pvdrdb_tools.PVDRDBQuery() pvr.connectToDB() @@ -212,8 +209,6 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): df = pd.read_csv("nodes.csv") points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] names = list(df['county']) - # Associated date range for the forecasts - dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") master_prediction_df = pd.DataFrame() # Create a logger logger = logging.getLogger(__name__) @@ -226,13 +221,31 @@ def pull_herbie_gefs_data(data, time_horizon, aws_profile): ch.setFormatter(formatter) # Add the handler to the logger logger.addHandler(ch) - client = Client(cluster) - result = [] - cluster.scale(jobs=4) - for date in dates: - for time_horizon in range(1, 19, 1): - if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) - delayed_results.append(hrrr_pred_df) - print(Counter(result)) - print(cluster.job_script()) \ No newline at end of file + # Do HRR up to 18 hours first (2 hour forecasts) + # Break into monthly chunks so the task graph stays manageable + date_chunks = pd.date_range("2018-01-01", "2022-12-31", freq="MS") # monthly start dates + + for chunk_start in date_chunks: + chunk_end = chunk_start + pd.offsets.MonthEnd(1) + dates = pd.date_range(chunk_start, chunk_end, freq="1h") + + # HRRR + delayed_results = [] + for date in dates: + for time_horizon in range(1, 19, 1): + if (date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) + delayed_results.append(hrrr_pred_df) + if delayed_results: + logger.info(f"Computing {len(delayed_results)} HRRR tasks for {chunk_start.strftime('%Y-%m')}") + dask.compute(*delayed_results, num_workers=20) + + # GEFS + delayed_results = [] + for date in dates: + for time_horizon in range(24, 78, 6): + if (date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: + delayed_results.append(delayed(pull_herbie_gefs_data)(date, time_horizon, pvr.aws)) + if delayed_results: + logger.info(f"Computing {len(delayed_results)} GEFS tasks for {chunk_start.strftime('%Y-%m')}") + dask.compute(*delayed_results, num_workers=20) diff --git a/data/generate_herbie_forecasts_local.py b/data/generate_herbie_forecasts_local.py deleted file mode 100644 index 9e171a3a..00000000 --- a/data/generate_herbie_forecasts_local.py +++ /dev/null @@ -1,227 +0,0 @@ -import pandas as pd -#from pvlib.forecast import HRRR -from herbie import Herbie - -from herbie.toolbox import EasyMap, pc -from herbie import paint -import numpy as np -import matplotlib.pyplot as plt -import shutil -from dask import delayed -import os -import dask -import logging -import time -from dask.distributed import Client, wait, as_completed -import pvdrdb_tools -import boto3 -from dask_jobqueue import SLURMCluster -import socket -from dask.distributed import Client -from collections import Counter - - -@delayed -def pull_herbie_hrr_data(date, time_horizon, aws_profile): - """ - Function for pulling Herbie data, which we will be parallelizing via Dask. - """ - for i in range(3): - try: - logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - master_pred_list = list() - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - master_pred_list.append(pred_df) - master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") - os.remove(file) - return master_pred_df - except Exception as e: - print(e) - logger.info(e) - time.sleep(5) # backoff - logger.info("Download failed for {date} {time_horizon} hr time horizon...") - return - -@delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): - """ - Similar function for Herbie GEFS data. - """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df - - - -forecast_dir = "C:/Users/kperry/data/" -if __name__ == "__main__": - # Connect to the db and get the associated AWS creds - pvr = pvdrdb_tools.PVDRDBQuery() - pvr.connectToDB() - # Connect to S3 and get all of the files that have already been inserted. - # we want to omit these files from new runs, and only run new cases - s3_client = boto3.client('s3', - aws_access_key_id=pvr.aws['key'], - aws_secret_access_key=pvr.aws['secret']) - paginator = s3_client.get_paginator('list_objects_v2') - pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") - file_keys = list() - for page in pages: - if 'Contents' in page: - for obj in page['Contents']: - if obj['Key'] != "REGROW/herbie_forecasts/raw/": - file_keys.append(obj['Key']) - existing_files = [os.path.basename(x) for x in file_keys] - # Read in the nodes we want to forecast on - df = pd.read_csv("nodes.csv") - points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] - names = list(df['county']) - # Associated date range for the forecasts - dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") - master_prediction_df = pd.DataFrame() - # Create a logger - logger = logging.getLogger(__name__) - logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) - # Create a console handler and set its level - ch = logging.StreamHandler() - ch.setLevel(logging.INFO) - # Create a formatter and add it to the handler - formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') - ch.setFormatter(formatter) - # Add the handler to the logger - logger.addHandler(ch) - # Do HRR up to 18 hours first (2 hour forecasts) - delayed_results = [] - for date in dates: - for time_horizon in range(1, 19, 1): - if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - hrrr_pred_df = delayed(pull_herbie_hrr_data)(date, time_horizon, pvr.aws) - delayed_results.append(hrrr_pred_df) - results = dask.compute(*delayed_results, num_workers=4) diff --git a/data/generate_herbie_forecasts_slurm.py b/data/generate_herbie_forecasts_slurm.py deleted file mode 100644 index fc661be8..00000000 --- a/data/generate_herbie_forecasts_slurm.py +++ /dev/null @@ -1,238 +0,0 @@ -import pandas as pd -#from pvlib.forecast import HRRR -from herbie import Herbie - -from herbie.toolbox import EasyMap, pc -from herbie import paint -import numpy as np -import matplotlib.pyplot as plt -import shutil -from dask import delayed -import os -import dask -import logging -import time -from dask.distributed import Client, wait, as_completed -import pvdrdb_tools -import boto3 -from dask_jobqueue import SLURMCluster -import socket -from dask.distributed import Client -from collections import Counter - - -@delayed -def pull_herbie_hrr_data(date, time_horizon, aws_profile): - """ - Function for pulling Herbie data, which we will be parallelizing via Dask. - """ - for i in range(3): - try: - logger.info(f"Processing values: {date} {time_horizon} hr time horizon...") - H = Herbie(date, - model="hrrr", - product="prs", - fxx=time_horizon - ) - file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover - #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) - #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature - #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point - # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html - tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", - ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":VGRD:80 m above ground:" + str(time_horizon) + " hour fcst", - ":RH:2 m above ground:" + str(time_horizon) + " hour fcst", - ":PRES:surface:" + str(time_horizon) + " hour fcst", - ":TMP:surface:" + str(time_horizon) + " hour fcst", - ":DPT:2 m above ground:" + str(time_horizon) + " hour fcst"] - master_pred_list = list() - for tag in tags: - ds = H.xarray(tag,remove_grib=True) - # get all of the closest forecasts to the WECC node points - dsi = ds.herbie.nearest_points(points=points, - names=names) - # Build out a dataframe for the predictions - pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) - pred_df['point_latitude'] = list(dsi.point_latitude.values) - pred_df['point_longitude'] = list(dsi.point_longitude.values) - pred_df['tag'] = tag - pred_df['forecast_time'] = date - pred_df['forecast_horizon_hrs'] = time_horizon - if "d2m" in dsi: - pred_df['value'] = list(dsi.d2m.values) - elif "tcc" in dsi: - pred_df['value'] = list(dsi.tcc.values) - elif "u" in dsi: - pred_df['value'] = list(dsi.u.values) - elif "v" in dsi: - pred_df['value'] = list(dsi.v.values) - elif "r2" in dsi: - pred_df['value'] = list(dsi.r2.values) - elif "sp" in dsi: - pred_df['value'] = list(dsi.sp.values) - elif "t" in dsi: - pred_df['value'] = list(dsi.t.values) - master_pred_list.append(pred_df) - master_pred_df = pd.concat(master_pred_list) - master_pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/'+ - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - logger.info(f"Finished processing {date} {time_horizon} hr time horizon...") - os.remove(file) - return master_pred_df - except Exception as e: - print(e) - logger.info(e) - time.sleep(5) # backoff - logger.info("Download failed for {date} {time_horizon} hr time horizon...") - return - -@delayed -def pull_herbie_gefs_data(data, time_horizon, aws_profile): - """ - Similar function for Herbie GEFS data. - """ - H = Herbie(date, - model="gefs", - fxx=time_horizon, - product="atmos.5b", - member="p01", - ) - file = H.download() - tags = ["UGRD:80 m", - "VGRD:80 m", - "TCDC", - #"RH", - #"PRES", - "TMP:surface", - "DPT:2 m"] - specific_tag_names = [":TCDC:475 mb:", - ":UGRD:80 m above ground:", - ":VGRD:80 m above ground:", - #":RH:2 m above ground:", - #":PRES:surface::", - "TMP:surface:", - "DPT:2 m above ground:"] - master_pred_list = list() - for tag in tags: - tag_df=H.inventory(tag) - tag_df = tag_df.reset_index(drop=True) - print(len(tag_df)) - tag_match = [x for x in specific_tag_names if - tag_df['variable'].iloc[0] in x][0] - index_val = tag_df[tag_df['search_this'].str.contains(tag_match)].iloc[0].name - ds = H.xarray(tag, remove_grib=True) - predictions = list() - for point in points: - if "d2m" in ds: - pred = ds['d2m'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "tcc" in ds: - pred = ds['tcc'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "u" in ds: - pred = ds['u'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "v" in ds: - pred = ds['v'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "r2" in ds: - pred = ds['r2'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "sp" in ds: - pred = ds['sp'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - elif "t" in ds: - pred = ds['t'].sel(longitude=point[0], - latitude=point[1], - method='nearest').values.reshape(1) - else: - break - predictions.append(pred) - predictions = list(np.concatenate(predictions)) - pred_df = pd.DataFrame() - pred_df['longitude'] = [point[0] for point in points] - pred_df['latitude'] = [point[1] for point in points] - pred_df['forecast_time'] = date - pred_df['time_horizon_hrs'] = time_horizon - pred_df['tag'] = tag - pred_df['value'] = predictions - pred_df.to_csv('s3://pvdrdb-transfer/REGROW/herbie_forecasts/raw/' + - date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv", - index=False, - storage_options=aws_profile) - # Delete the file in question (to save storage space) - os.remove(file) - return pred_df - - - -forecast_dir = "C:/Users/kperry/data/" -if __name__ == "__main__": - # Declare SLURM Cluster - cluster = SLURMCluster( - cores=18, - memory='24GB', - account='pvfleets24', - walltime='00:30:00', - processes=17, - queue='shared' - ) - # Connect to the db and get the associated AWS creds - pvr = pvdrdb_tools.PVDRDBQuery() - pvr.connectToDB() - # Connect to S3 and get all of the files that have already been inserted. - # we want to omit these files from new runs, and only run new cases - s3_client = boto3.client('s3', - aws_access_key_id=pvr.aws['key'], - aws_secret_access_key=pvr.aws['secret']) - paginator = s3_client.get_paginator('list_objects_v2') - pages = paginator.paginate(Bucket="pvdrdb-transfer", Prefix="REGROW/herbie_forecasts/raw/") - file_keys = list() - for page in pages: - if 'Contents' in page: - for obj in page['Contents']: - if obj['Key'] != "REGROW/herbie_forecasts/raw/": - file_keys.append(obj['Key']) - existing_files = [os.path.basename(x) for x in file_keys] - # Read in the nodes we want to forecast on - df = pd.read_csv("nodes.csv") - points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] - names = list(df['county']) - # Associated date range for the forecasts - dates = pd.date_range("2018-01-01", "2022-12-31", freq="6H") - master_prediction_df = pd.DataFrame() - # Create a logger - logger = logging.getLogger(__name__) - logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.DEBUG) - # Create a console handler and set its level - ch = logging.StreamHandler() - ch.setLevel(logging.INFO) - # Create a formatter and add it to the handler - formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') - ch.setFormatter(formatter) - # Add the handler to the logger - logger.addHandler(ch) - # Do HRR up to 18 hours first (2 hour forecasts) - client = Client(cluster) - result = [] - cluster.scale(jobs=4) - for date in dates: - for time_horizon in range(1, 19, 1): - if ( date.strftime("%Y-%m-%d_%H_%M_%S") + "_" + str(time_horizon) + "hr.csv") not in existing_files: - result.append(client.submit(pull_herbie_hrr_data(date, time_horizon, pvr.aws)).result()) - print(Counter(result)) - print(cluster.job_script()) \ No newline at end of file diff --git a/data/slurm/slurm.sh b/data/slurm/slurm.sh new file mode 100644 index 00000000..12bb9512 --- /dev/null +++ b/data/slurm/slurm.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --job-name=herbie_forecasts +#SBATCH --account=pvfleets24 +#SBATCH --partition=standard +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=20 +#SBATCH --mem=32G +#SBATCH --time=24:00:00 +#SBATCH --output=/kfs2/projects/pvfleets24/repos/regrow/data/slurm_outputs/herbie_%j.out +#SBATCH --error=/kfs2/projects/pvfleets24/repos/regrow/data/slurm_outputs/herbie_%j.err +#SBATCH --mail-type=BEGIN,END,FAIL +#SBATCH --mail-user=kirsten.perry@nlr.gov + +ml mamba +mamba activate /kfs2/projects/pvfleets24/envs/regrow + + +# Run the script +cd /kfs2/projects/pvfleets24/repos/regrow/data +python generate_herbie_forecasts.py diff --git a/data/slurm_outputs/herbie_13573894.err b/data/slurm_outputs/herbie_13573894.err new file mode 100644 index 00000000..123bee3a --- /dev/null +++ b/data/slurm_outputs/herbie_13573894.err @@ -0,0 +1,32442 @@ +2026-04-29 08:58:59,700 - __main__ - INFO - Computing 12978 HRRR tasks for 2018-01 +2026-04-29 08:59:06,234 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 15 hr time horizon... +2026-04-29 08:59:06,235 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 2 hr time horizon... +2026-04-29 08:59:06,236 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 16 hr time horizon... +2026-04-29 08:59:06,237 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 1 hr time horizon... +2026-04-29 08:59:06,239 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 8 hr time horizon... +2026-04-29 08:59:06,239 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 17 hr time horizon... +2026-04-29 08:59:06,240 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 17 hr time horizon... +2026-04-29 08:59:06,241 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 9 hr time horizon... +2026-04-29 08:59:06,241 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 16 hr time horizon... +2026-04-29 08:59:06,242 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 15 hr time horizon... +2026-04-29 08:59:06,243 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 6 hr time horizon... +2026-04-29 08:59:06,243 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 11 hr time horizon... +2026-04-29 08:59:06,244 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 5 hr time horizon... +2026-04-29 08:59:06,245 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 4 hr time horizon... +2026-04-29 08:59:06,246 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 18 hr time horizon... +2026-04-29 08:59:06,246 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 2 hr time horizon... +2026-04-29 08:59:06,247 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 7 hr time horizon... +2026-04-29 08:59:06,247 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 15 hr time horizon... +2026-04-29 08:59:06,248 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 11 hr time horizon... +2026-04-29 08:59:06,249 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:29,305 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 15 hr time horizon... +2026-04-29 08:59:29,306 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 2 hr time horizon... +2026-04-29 08:59:29,310 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 17 hr time horizon... +2026-04-29 08:59:29,311 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 5 hr time horizon... +2026-04-29 08:59:29,317 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 15 hr time horizon... +2026-04-29 08:59:29,324 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 17 hr time horizon... +2026-04-29 08:59:29,325 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 2 hr time horizon... +2026-04-29 08:59:29,332 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 11 hr time horizon... +2026-04-29 08:59:29,332 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 16 hr time horizon... +2026-04-29 08:59:29,337 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 16 hr time horizon... +2026-04-29 08:59:29,338 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 4 hr time horizon... +2026-04-29 08:59:29,341 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 15 hr time horizon... +2026-04-29 08:59:29,342 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 15 hr time horizon... +2026-04-29 08:59:29,343 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 6 hr time horizon... +2026-04-29 08:59:29,344 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 18 hr time horizon... +2026-04-29 08:59:29,348 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 8 hr time horizon... +2026-04-29 08:59:29,354 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 9 hr time horizon... +2026-04-29 08:59:29,355 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 11 hr time horizon... +2026-04-29 08:59:29,358 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 1 hr time horizon... +2026-04-29 08:59:29,363 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 3 hr time horizon... +2026-04-29 08:59:29,369 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 7 hr time horizon... +2026-04-29 08:59:29,412 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 4 hr time horizon... +2026-04-29 08:59:29,414 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 13 hr time horizon... +2026-04-29 08:59:29,431 - __main__ - INFO - Processing values: 2018-01-21 07:00:00 13 hr time horizon... +2026-04-29 08:59:29,455 - __main__ - INFO - Processing values: 2018-01-14 09:00:00 3 hr time horizon... +2026-04-29 08:59:29,458 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 12 hr time horizon... +2026-04-29 08:59:29,459 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 8 hr time horizon... +2026-04-29 08:59:29,461 - __main__ - INFO - Processing values: 2018-01-09 19:00:00 15 hr time horizon... +2026-04-29 08:59:29,463 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 1 hr time horizon... +2026-04-29 08:59:29,465 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 11 hr time horizon... +2026-04-29 08:59:29,468 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 3 hr time horizon... +2026-04-29 08:59:29,470 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 14 hr time horizon... +2026-04-29 08:59:29,471 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 9 hr time horizon... +2026-04-29 08:59:29,472 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 18 hr time horizon... +2026-04-29 08:59:29,474 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 17 hr time horizon... +2026-04-29 08:59:29,474 - __main__ - INFO - Processing values: 2018-01-26 16:00:00 11 hr time horizon... +2026-04-29 08:59:29,476 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 13 hr time horizon... +2026-04-29 08:59:29,477 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 2 hr time horizon... +2026-04-29 08:59:29,516 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 7 hr time horizon... +2026-04-29 08:59:29,536 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:43,903 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:43,920 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:44,197 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:44,220 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 08:59:44,676 - __main__ - INFO - No valid message found: PosixPath('/home/kperry/data/hrrr/20180111/subset_8818165b__hrrr.t01z.wrfprsf14.grib2') +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:44,684 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 18 hr time horizon... +2026-04-29 08:59:44,686 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:44,718 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 12 hr time horizon... +2026-04-29 08:59:44,718 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:44,974 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 2 hr time horizon... +2026-04-29 08:59:45,001 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,407 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 12 hr time horizon... +2026-04-29 08:59:45,429 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,493 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 14 hr time horizon... +2026-04-29 08:59:45,521 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,548 - __main__ - INFO - Finished processing 2018-01-21 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,568 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,689 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 3 hr time horizon... +2026-04-29 08:59:45,717 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:45,971 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 1 hr time horizon... +2026-04-29 08:59:45,982 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 11 hr time horizon... +2026-04-29 08:59:45,994 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 17 hr time horizon... +2026-04-29 08:59:46,014 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:46,091 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 3 hr time horizon... +2026-04-29 08:59:46,108 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 16 hr time horizon... +2026-04-29 08:59:46,178 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 9 hr time horizon... +2026-04-29 08:59:46,200 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:46,385 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 12 hr time horizon... +2026-04-29 08:59:46,404 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 17 hr time horizon... +2026-04-29 08:59:46,431 - __main__ - INFO - Finished processing 2018-01-14 09:00:00 3 hr time horizon... +2026-04-29 08:59:46,447 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:46,540 - __main__ - INFO - Finished processing 2018-01-26 16:00:00 11 hr time horizon... +2026-04-29 08:59:46,548 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 7 hr time horizon... +2026-04-29 08:59:46,563 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 12 hr time horizon... +2026-04-29 08:59:46,572 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 11 hr time horizon... +2026-04-29 08:59:46,690 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 17 hr time horizon... +2026-04-29 08:59:46,712 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:46,954 - __main__ - INFO - Finished processing 2018-01-09 19:00:00 15 hr time horizon... +2026-04-29 08:59:46,976 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 2 hr time horizon... +2026-04-29 08:59:47,416 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 13 hr time horizon... +2026-04-29 08:59:47,433 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 3 hr time horizon... +2026-04-29 08:59:49,683 - __main__ - INFO - Download failed for {date} {time_horizon} hr time horizon... +2026-04-29 08:59:49,684 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:57,887 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:57,908 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:58,056 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 15 hr time horizon... +2026-04-29 08:59:58,057 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 17 hr time horizon... +2026-04-29 08:59:58,081 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 11 hr time horizon... +2026-04-29 08:59:58,081 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:58,991 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 12 hr time horizon... +2026-04-29 08:59:59,015 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:59,524 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 17 hr time horizon... +2026-04-29 08:59:59,543 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 08:59:59,870 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 7 hr time horizon... +2026-04-29 08:59:59,894 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:00,344 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:00,365 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:00,535 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 1 hr time horizon... +2026-04-29 09:00:00,549 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 17 hr time horizon... +2026-04-29 09:00:00,560 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 3 hr time horizon... +2026-04-29 09:00:00,573 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:00,745 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 17 hr time horizon... +2026-04-29 09:00:00,765 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:00,920 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 15 hr time horizon... +2026-04-29 09:00:00,945 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:01,640 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 11 hr time horizon... +2026-04-29 09:00:01,659 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 12 hr time horizon... +2026-04-29 09:00:01,675 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:01,693 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:01,913 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 10 hr time horizon... +2026-04-29 09:00:01,931 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:02,106 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 6 hr time horizon... +2026-04-29 09:00:02,128 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 18 hr time horizon... +2026-04-29 09:00:02,212 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 3 hr time horizon... +2026-04-29 09:00:02,230 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:02,312 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 11 hr time horizon... +2026-04-29 09:00:02,331 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 5 hr time horizon... +2026-04-29 09:00:02,478 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 2 hr time horizon... +2026-04-29 09:00:02,495 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:02,624 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 12 hr time horizon... +2026-04-29 09:00:02,646 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:04,953 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 17 hr time horizon... +2026-04-29 09:00:04,977 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:11,582 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 7 hr time horizon... +2026-04-29 09:00:11,602 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:12,397 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 11 hr time horizon... +2026-04-29 09:00:12,418 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:12,793 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 7 hr time horizon... +2026-04-29 09:00:12,822 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:13,334 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 2 hr time horizon... +2026-04-29 09:00:13,349 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:14,081 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 12 hr time horizon... +2026-04-29 09:00:14,104 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:14,694 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:14,717 - __main__ - INFO - Processing values: 2018-01-15 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:14,743 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 12 hr time horizon... +2026-04-29 09:00:14,771 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:14,831 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 18 hr time horizon... +2026-04-29 09:00:14,858 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:15,049 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:15,080 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:17,024 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 7 hr time horizon... +2026-04-29 09:00:17,050 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:17,539 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:17,565 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:17,805 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 10 hr time horizon... +2026-04-29 09:00:17,828 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 7 hr time horizon... +2026-04-29 09:00:17,979 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 18 hr time horizon... +2026-04-29 09:00:17,999 - __main__ - INFO - Processing values: 2018-01-01 04:00:00 3 hr time horizon... +2026-04-29 09:00:18,104 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 12 hr time horizon... +2026-04-29 09:00:18,124 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 15 hr time horizon... +2026-04-29 09:00:18,206 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 4 hr time horizon... +2026-04-29 09:00:18,226 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 7 hr time horizon... +2026-04-29 09:00:18,238 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 5 hr time horizon... +2026-04-29 09:00:18,257 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 4 hr time horizon... +2026-04-29 09:00:18,276 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 11 hr time horizon... +2026-04-29 09:00:18,296 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 2 hr time horizon... +2026-04-29 09:00:18,395 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 16 hr time horizon... +2026-04-29 09:00:18,413 - __main__ - INFO - Processing values: 2018-01-02 12:00:00 2 hr time horizon... +2026-04-29 09:00:18,469 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 18 hr time horizon... +2026-04-29 09:00:18,490 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:21,758 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 9 hr time horizon... +2026-04-29 09:00:21,779 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:26,857 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 14 hr time horizon... +2026-04-29 09:00:26,879 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:27,493 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 11 hr time horizon... +2026-04-29 09:00:27,518 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:27,710 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:00:27,733 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:28,327 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 10 hr time horizon... +2026-04-29 09:00:28,357 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:29,027 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 2 hr time horizon... +2026-04-29 09:00:29,047 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:29,169 - __main__ - INFO - Finished processing 2018-01-15 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:29,193 - __main__ - INFO - Processing values: 2018-01-24 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:30,274 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 1 hr time horizon... +2026-04-29 09:00:30,298 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:30,512 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 1 hr time horizon... +2026-04-29 09:00:30,529 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 8 hr time horizon... +2026-04-29 09:00:30,666 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 12 hr time horizon... +2026-04-29 09:00:30,698 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:31,126 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 16 hr time horizon... +2026-04-29 09:00:31,146 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:33,290 - __main__ - INFO - Finished processing 2018-01-01 04:00:00 3 hr time horizon... +2026-04-29 09:00:33,312 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:33,381 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 15 hr time horizon... +2026-04-29 09:00:33,404 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 16 hr time horizon... +2026-04-29 09:00:33,514 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 4 hr time horizon... +2026-04-29 09:00:33,536 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:33,797 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 13 hr time horizon... +2026-04-29 09:00:33,820 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:34,738 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 5 hr time horizon... +2026-04-29 09:00:34,760 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:34,897 - __main__ - INFO - Finished processing 2018-01-02 12:00:00 2 hr time horizon... +2026-04-29 09:00:34,916 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:37,129 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 7 hr time horizon... +2026-04-29 09:00:37,156 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:37,282 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 2 hr time horizon... +2026-04-29 09:00:37,303 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:38,128 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 7 hr time horizon... +2026-04-29 09:00:38,151 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 15 hr time horizon... +2026-04-29 09:00:38,551 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 10 hr time horizon... +2026-04-29 09:00:38,577 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:43,174 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 2 hr time horizon... +2026-04-29 09:00:43,197 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:43,315 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 3 hr time horizon... +2026-04-29 09:00:43,333 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:43,878 - __main__ - INFO - Finished processing 2018-01-24 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:43,904 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:44,257 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 18 hr time horizon... +2026-04-29 09:00:44,285 - __main__ - INFO - Processing values: 2018-01-09 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:44,522 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 9 hr time horizon... +2026-04-29 09:00:44,546 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:45,091 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 8 hr time horizon... +2026-04-29 09:00:45,126 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:46,441 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 1 hr time horizon... +2026-04-29 09:00:46,462 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:47,415 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:47,441 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:48,352 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:48,378 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:48,517 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 1 hr time horizon... +2026-04-29 09:00:48,542 - __main__ - INFO - Processing values: 2018-01-13 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:49,391 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 16 hr time horizon... +2026-04-29 09:00:49,416 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:49,513 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 17 hr time horizon... +2026-04-29 09:00:49,541 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:50,132 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 4 hr time horizon... +2026-04-29 09:00:50,154 - __main__ - INFO - Processing values: 2018-01-15 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:50,504 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 14 hr time horizon... +2026-04-29 09:00:50,530 - __main__ - INFO - Processing values: 2018-01-10 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:51,090 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 10 hr time horizon... +2026-04-29 09:00:51,112 - __main__ - INFO - Processing values: 2018-01-01 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:52,337 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 1 hr time horizon... +2026-04-29 09:00:52,357 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:52,847 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 8 hr time horizon... +2026-04-29 09:00:52,873 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:53,387 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 6 hr time horizon... +2026-04-29 09:00:53,409 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:54,357 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 15 hr time horizon... +2026-04-29 09:00:54,379 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:55,172 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 2 hr time horizon... +2026-04-29 09:00:55,192 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:58,820 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 4 hr time horizon... +2026-04-29 09:00:58,843 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:00:59,525 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 12 hr time horizon... +2026-04-29 09:00:59,548 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:00,668 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 8 hr time horizon... +2026-04-29 09:01:00,699 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:01,528 - __main__ - INFO - Finished processing 2018-01-09 06:00:00 7 hr time horizon... +2026-04-29 09:01:01,552 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 15 hr time horizon... +2026-04-29 09:01:01,617 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:01,641 - __main__ - INFO - Processing values: 2018-01-22 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:01,707 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 6 hr time horizon... +2026-04-29 09:01:01,731 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 1 hr time horizon... +2026-04-29 09:01:01,787 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 7 hr time horizon... +2026-04-29 09:01:01,805 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:02,327 - __main__ - INFO - Finished processing 2018-01-13 22:00:00 13 hr time horizon... +2026-04-29 09:01:02,349 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:03,203 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 16 hr time horizon... +2026-04-29 09:01:03,224 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:04,708 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 17 hr time horizon... +2026-04-29 09:01:04,731 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:05,049 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:05,077 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:05,479 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 14 hr time horizon... +2026-04-29 09:01:05,500 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:06,110 - __main__ - INFO - Finished processing 2018-01-01 04:00:00 8 hr time horizon... +2026-04-29 09:01:06,127 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:06,292 - __main__ - INFO - Finished processing 2018-01-10 10:00:00 18 hr time horizon... +2026-04-29 09:01:06,320 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:06,812 - __main__ - INFO - Finished processing 2018-01-15 17:00:00 3 hr time horizon... +2026-04-29 09:01:06,832 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:07,441 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 9 hr time horizon... +2026-04-29 09:01:07,463 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:08,770 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 17 hr time horizon... +2026-04-29 09:01:08,793 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:08,964 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 13 hr time horizon... +2026-04-29 09:01:08,987 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:09,780 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 11 hr time horizon... +2026-04-29 09:01:09,801 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:11,319 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 18 hr time horizon... +2026-04-29 09:01:11,342 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:13,633 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:01:13,655 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:15,070 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 9 hr time horizon... +2026-04-29 09:01:15,099 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:16,881 - __main__ - INFO - Finished processing 2018-01-22 12:00:00 5 hr time horizon... +2026-04-29 09:01:16,903 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 9 hr time horizon... +2026-04-29 09:01:16,945 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 1 hr time horizon... +2026-04-29 09:01:16,963 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 16 hr time horizon... +2026-04-29 09:01:17,021 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 2 hr time horizon... +2026-04-29 09:01:17,041 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:17,159 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 1 hr time horizon... +2026-04-29 09:01:17,182 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:17,510 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 15 hr time horizon... +2026-04-29 09:01:17,531 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:18,384 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 6 hr time horizon... +2026-04-29 09:01:18,414 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:20,669 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:20,693 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:21,384 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 6 hr time horizon... +2026-04-29 09:01:21,404 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 3 hr time horizon... +2026-04-29 09:01:21,404 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 8 hr time horizon... +2026-04-29 09:01:21,435 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:21,719 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 9 hr time horizon... +2026-04-29 09:01:21,742 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:22,345 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 18 hr time horizon... +2026-04-29 09:01:22,367 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:22,445 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 12 hr time horizon... +2026-04-29 09:01:22,467 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:22,926 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 10 hr time horizon... +2026-04-29 09:01:22,945 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:24,093 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 2 hr time horizon... +2026-04-29 09:01:24,116 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:24,981 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 11 hr time horizon... +2026-04-29 09:01:25,007 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:25,993 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 7 hr time horizon... +2026-04-29 09:01:26,022 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:27,025 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 10 hr time horizon... +2026-04-29 09:01:27,052 - __main__ - INFO - Processing values: 2018-01-21 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:29,868 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 12 hr time horizon... +2026-04-29 09:01:29,892 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:32,369 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 8 hr time horizon... +2026-04-29 09:01:32,388 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:32,940 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 10 hr time horizon... +2026-04-29 09:01:32,961 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 8 hr time horizon... +2026-04-29 09:01:33,026 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 16 hr time horizon... +2026-04-29 09:01:33,054 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:33,273 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:33,296 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:33,952 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 17 hr time horizon... +2026-04-29 09:01:33,986 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:35,597 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 18 hr time horizon... +2026-04-29 09:01:35,619 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:35,988 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 4 hr time horizon... +2026-04-29 09:01:36,012 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:36,210 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 4 hr time horizon... +2026-04-29 09:01:36,237 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:36,572 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 16 hr time horizon... +2026-04-29 09:01:36,598 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:36,846 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 8 hr time horizon... +2026-04-29 09:01:36,869 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:37,057 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 15 hr time horizon... +2026-04-29 09:01:37,082 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:37,282 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 13 hr time horizon... +2026-04-29 09:01:37,309 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:37,907 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 7 hr time horizon... +2026-04-29 09:01:37,932 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:38,906 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 9 hr time horizon... +2026-04-29 09:01:38,930 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:39,165 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 9 hr time horizon... +2026-04-29 09:01:39,186 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:40,259 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 3 hr time horizon... +2026-04-29 09:01:40,281 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:41,295 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 6 hr time horizon... +2026-04-29 09:01:41,317 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:42,005 - __main__ - INFO - Finished processing 2018-01-21 19:00:00 11 hr time horizon... +2026-04-29 09:01:42,028 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 4 hr time horizon... +2026-04-29 09:01:42,581 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 13 hr time horizon... +2026-04-29 09:01:42,603 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:46,095 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 15 hr time horizon... +2026-04-29 09:01:46,114 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:47,548 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 11 hr time horizon... +2026-04-29 09:01:47,577 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:47,779 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 15 hr time horizon... +2026-04-29 09:01:47,799 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:48,881 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:48,910 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:49,483 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:49,503 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:49,586 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 10 hr time horizon... +2026-04-29 09:01:49,609 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:50,032 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 3 hr time horizon... +2026-04-29 09:01:50,053 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:51,188 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 18 hr time horizon... +2026-04-29 09:01:51,210 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:51,380 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 11 hr time horizon... +2026-04-29 09:01:51,399 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 15 hr time horizon... +2026-04-29 09:01:51,472 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 7 hr time horizon... +2026-04-29 09:01:51,492 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:51,675 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 9 hr time horizon... +2026-04-29 09:01:51,700 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:51,937 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 4 hr time horizon... +2026-04-29 09:01:51,959 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:53,094 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 17 hr time horizon... +2026-04-29 09:01:53,114 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:53,962 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 7 hr time horizon... +2026-04-29 09:01:53,987 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:54,114 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 13 hr time horizon... +2026-04-29 09:01:54,145 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:01:55,959 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 6 hr time horizon... +2026-04-29 09:01:55,981 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 18 hr time horizon... +2026-04-29 09:01:55,988 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 7 hr time horizon... +2026-04-29 09:01:56,012 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 16 hr time horizon... +2026-04-29 09:01:56,469 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 9 hr time horizon... +2026-04-29 09:01:56,490 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:01,600 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 10 hr time horizon... +2026-04-29 09:02:01,621 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:01,656 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 4 hr time horizon... +2026-04-29 09:02:01,680 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:03,004 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 2 hr time horizon... +2026-04-29 09:02:03,026 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:03,327 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 1 hr time horizon... +2026-04-29 09:02:03,349 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:03,870 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 12 hr time horizon... +2026-04-29 09:02:03,896 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:04,753 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 7 hr time horizon... +2026-04-29 09:02:04,774 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:05,475 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 11 hr time horizon... +2026-04-29 09:02:05,499 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:05,659 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 17 hr time horizon... +2026-04-29 09:02:05,685 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:06,066 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 10 hr time horizon... +2026-04-29 09:02:06,088 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:07,098 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 15 hr time horizon... +2026-04-29 09:02:07,124 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:09,016 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 11 hr time horizon... +2026-04-29 09:02:09,021 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 12 hr time horizon... +2026-04-29 09:02:09,034 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:09,041 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 11 hr time horizon... +2026-04-29 09:02:09,045 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 14 hr time horizon... +2026-04-29 09:02:09,061 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 12 hr time horizon... +2026-04-29 09:02:09,073 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 13 hr time horizon... +2026-04-29 09:02:09,076 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:09,753 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:09,778 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 8 hr time horizon... +2026-04-29 09:02:09,905 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 9 hr time horizon... +2026-04-29 09:02:09,927 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:10,060 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:10,087 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:12,059 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 18 hr time horizon... +2026-04-29 09:02:12,080 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 2 hr time horizon... +2026-04-29 09:02:12,253 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 16 hr time horizon... +2026-04-29 09:02:12,279 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 15 hr time horizon... +2026-04-29 09:02:12,598 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 13 hr time horizon... +2026-04-29 09:02:12,620 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:16,680 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:16,700 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:18,732 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:18,752 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:19,016 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 5 hr time horizon... +2026-04-29 09:02:19,039 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:19,234 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 2 hr time horizon... +2026-04-29 09:02:19,254 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:19,309 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 4 hr time horizon... +2026-04-29 09:02:19,328 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:20,075 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 15 hr time horizon... +2026-04-29 09:02:20,095 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:20,705 - __main__ - INFO - Finished processing 2018-01-29 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:20,724 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:22,198 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 17 hr time horizon... +2026-04-29 09:02:22,221 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:23,199 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 17 hr time horizon... +2026-04-29 09:02:23,222 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:24,124 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 13 hr time horizon... +2026-04-29 09:02:24,153 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:24,840 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 12 hr time horizon... +2026-04-29 09:02:24,860 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 3 hr time horizon... +2026-04-29 09:02:24,874 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:24,895 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 8 hr time horizon... +2026-04-29 09:02:24,911 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 14 hr time horizon... +2026-04-29 09:02:24,933 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:25,537 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 8 hr time horizon... +2026-04-29 09:02:25,557 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:25,714 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 15 hr time horizon... +2026-04-29 09:02:25,736 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:26,163 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:02:26,187 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:27,452 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 14 hr time horizon... +2026-04-29 09:02:27,477 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:28,394 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 15 hr time horizon... +2026-04-29 09:02:28,415 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:28,942 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 2 hr time horizon... +2026-04-29 09:02:28,964 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:30,260 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 13 hr time horizon... +2026-04-29 09:02:30,280 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:33,650 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:33,689 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 3 hr time horizon... +2026-04-29 09:02:33,706 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 14 hr time horizon... +2026-04-29 09:02:33,738 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:34,699 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 16 hr time horizon... +2026-04-29 09:02:34,719 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:35,031 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 12 hr time horizon... +2026-04-29 09:02:35,054 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:35,376 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 4 hr time horizon... +2026-04-29 09:02:35,399 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:36,297 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 17 hr time horizon... +2026-04-29 09:02:36,317 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:36,700 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 14 hr time horizon... +2026-04-29 09:02:36,725 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:02:37,176 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:37,208 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:37,231 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 1 hr time horizon... +2026-04-29 09:02:37,252 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:39,882 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 3 hr time horizon... +2026-04-29 09:02:39,900 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:40,228 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 11 hr time horizon... +2026-04-29 09:02:40,252 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:40,381 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:40,402 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:41,132 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 7 hr time horizon... +2026-04-29 09:02:41,153 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 13 hr time horizon... +2026-04-29 09:02:41,227 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 15 hr time horizon... +2026-04-29 09:02:41,252 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:41,631 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 9 hr time horizon... +2026-04-29 09:02:41,653 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 11 hr time horizon... +2026-04-29 09:02:42,094 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 15 hr time horizon... +2026-04-29 09:02:42,118 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:45,315 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 13 hr time horizon... +2026-04-29 09:02:45,337 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:46,805 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 3 hr time horizon... +2026-04-29 09:02:46,828 - __main__ - INFO - Processing values: 2018-01-26 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:46,904 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 15 hr time horizon... +2026-04-29 09:02:46,929 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:50,079 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 3 hr time horizon... +2026-04-29 09:02:50,098 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:50,622 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:50,642 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:51,257 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 11 hr time horizon... +2026-04-29 09:02:51,282 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:51,663 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 18 hr time horizon... +2026-04-29 09:02:51,672 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 2 hr time horizon... +2026-04-29 09:02:51,689 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 9 hr time horizon... +2026-04-29 09:02:51,697 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:51,900 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 17 hr time horizon... +2026-04-29 09:02:51,923 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:52,213 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 7 hr time horizon... +2026-04-29 09:02:52,236 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:54,107 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 11 hr time horizon... +2026-04-29 09:02:54,130 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:54,357 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 18 hr time horizon... +2026-04-29 09:02:54,380 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:55,306 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 3 hr time horizon... +2026-04-29 09:02:55,334 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:56,725 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 14 hr time horizon... +2026-04-29 09:02:56,747 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:58,028 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:58,049 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:58,095 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 13 hr time horizon... +2026-04-29 09:02:58,118 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:58,618 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 15 hr time horizon... +2026-04-29 09:02:58,642 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 5 hr time horizon... +2026-04-29 09:02:58,678 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 18 hr time horizon... +2026-04-29 09:02:58,702 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:59,219 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 11 hr time horizon... +2026-04-29 09:02:59,246 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:02:59,765 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 9 hr time horizon... +2026-04-29 09:02:59,789 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:01,790 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 14 hr time horizon... +2026-04-29 09:03:01,811 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:03,876 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:03,900 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:04,584 - __main__ - INFO - Finished processing 2018-01-26 15:00:00 4 hr time horizon... +2026-04-29 09:03:04,607 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:06,558 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 12 hr time horizon... +2026-04-29 09:03:06,583 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:06,931 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:06,964 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:07,845 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:07,868 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:07,942 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:07,975 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:08,537 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:08,568 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 13 hr time horizon... +2026-04-29 09:03:08,573 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:08,594 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:09,173 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 17 hr time horizon... +2026-04-29 09:03:09,196 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:10,443 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 6 hr time horizon... +2026-04-29 09:03:10,474 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:11,563 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 8 hr time horizon... +2026-04-29 09:03:11,586 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:12,143 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 14 hr time horizon... +2026-04-29 09:03:12,170 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:13,131 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 14 hr time horizon... +2026-04-29 09:03:13,157 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:14,053 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 5 hr time horizon... +2026-04-29 09:03:14,076 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 3 hr time horizon... +2026-04-29 09:03:14,077 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 14 hr time horizon... +2026-04-29 09:03:14,098 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:14,475 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 6 hr time horizon... +2026-04-29 09:03:14,498 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:14,820 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 6 hr time horizon... +2026-04-29 09:03:14,844 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:15,500 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 2 hr time horizon... +2026-04-29 09:03:15,520 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:15,999 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 17 hr time horizon... +2026-04-29 09:03:16,021 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:18,039 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:18,061 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:19,850 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 7 hr time horizon... +2026-04-29 09:03:19,872 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:20,862 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 10 hr time horizon... +2026-04-29 09:03:20,895 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:22,614 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:22,643 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:23,203 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 12 hr time horizon... +2026-04-29 09:03:23,223 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:23,503 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 11 hr time horizon... +2026-04-29 09:03:23,533 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:23,740 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 13 hr time horizon... +2026-04-29 09:03:23,759 - __main__ - INFO - Processing values: 2018-01-07 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:24,974 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 11 hr time horizon... +2026-04-29 09:03:24,995 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:25,233 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 2 hr time horizon... +2026-04-29 09:03:25,253 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:25,749 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 14 hr time horizon... +2026-04-29 09:03:25,769 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:26,633 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:26,664 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:27,764 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 8 hr time horizon... +2026-04-29 09:03:27,787 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:28,412 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 14 hr time horizon... +2026-04-29 09:03:28,441 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:28,633 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 3 hr time horizon... +2026-04-29 09:03:28,662 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:29,323 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 7 hr time horizon... +2026-04-29 09:03:29,345 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:29,409 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 17 hr time horizon... +2026-04-29 09:03:29,429 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:29,572 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 2 hr time horizon... +2026-04-29 09:03:29,601 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:29,996 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 16 hr time horizon... +2026-04-29 09:03:30,014 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 12 hr time horizon... +2026-04-29 09:03:30,211 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 2 hr time horizon... +2026-04-29 09:03:30,228 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:31,296 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 17 hr time horizon... +2026-04-29 09:03:31,318 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:33,060 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 18 hr time horizon... +2026-04-29 09:03:33,082 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:35,010 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 4 hr time horizon... +2026-04-29 09:03:35,038 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:35,560 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 3 hr time horizon... +2026-04-29 09:03:35,580 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:37,182 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:37,204 - __main__ - INFO - Processing values: 2018-01-13 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:38,062 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 3 hr time horizon... +2026-04-29 09:03:38,082 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:39,038 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 5 hr time horizon... +2026-04-29 09:03:39,060 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:39,843 - __main__ - INFO - Finished processing 2018-01-07 13:00:00 9 hr time horizon... +2026-04-29 09:03:39,867 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 14 hr time horizon... +2026-04-29 09:03:40,033 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 3 hr time horizon... +2026-04-29 09:03:40,056 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:41,234 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 16 hr time horizon... +2026-04-29 09:03:41,258 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:42,319 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 11 hr time horizon... +2026-04-29 09:03:42,342 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:42,857 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 2 hr time horizon... +2026-04-29 09:03:42,884 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:43,669 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:03:43,692 - __main__ - INFO - Processing values: 2018-01-24 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:43,801 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:43,824 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:43,909 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 10 hr time horizon... +2026-04-29 09:03:43,929 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:44,648 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 12 hr time horizon... +2026-04-29 09:03:44,675 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:45,002 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 5 hr time horizon... +2026-04-29 09:03:45,024 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:45,523 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 17 hr time horizon... +2026-04-29 09:03:45,547 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:45,848 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 1 hr time horizon... +2026-04-29 09:03:45,869 - __main__ - INFO - Processing values: 2018-01-05 12:00:00 9 hr time horizon... +2026-04-29 09:03:46,026 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 12 hr time horizon... +2026-04-29 09:03:46,051 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:47,126 - __main__ - INFO - Finished processing 2018-01-14 21:00:00 11 hr time horizon... +2026-04-29 09:03:47,148 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:48,773 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 10 hr time horizon... +2026-04-29 09:03:48,796 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:50,706 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 13 hr time horizon... +2026-04-29 09:03:50,727 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:52,232 - __main__ - INFO - Finished processing 2018-01-13 06:00:00 14 hr time horizon... +2026-04-29 09:03:52,256 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:53,553 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 3 hr time horizon... +2026-04-29 09:03:53,580 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:54,044 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 16 hr time horizon... +2026-04-29 09:03:54,067 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:54,602 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 14 hr time horizon... +2026-04-29 09:03:54,624 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:55,613 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 3 hr time horizon... +2026-04-29 09:03:55,633 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:55,824 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 5 hr time horizon... +2026-04-29 09:03:55,845 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:57,348 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:57,375 - __main__ - INFO - Processing values: 2018-01-02 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:58,576 - __main__ - INFO - Finished processing 2018-01-24 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:58,601 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 7 hr time horizon... +2026-04-29 09:03:58,617 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 13 hr time horizon... +2026-04-29 09:03:58,647 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:03:59,345 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:59,379 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:03:59,495 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 14 hr time horizon... +2026-04-29 09:03:59,520 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:00,232 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:00,253 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:01,048 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 18 hr time horizon... +2026-04-29 09:04:01,074 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 3 hr time horizon... +2026-04-29 09:04:01,253 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 4 hr time horizon... +2026-04-29 09:04:01,277 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:01,447 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 1 hr time horizon... +2026-04-29 09:04:01,467 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:03,465 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 3 hr time horizon... +2026-04-29 09:04:03,485 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:05,233 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 16 hr time horizon... +2026-04-29 09:04:05,256 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:07,747 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 9 hr time horizon... +2026-04-29 09:04:07,765 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 5 hr time horizon... +2026-04-29 09:04:07,767 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 12 hr time horizon... +2026-04-29 09:04:07,791 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:08,224 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 8 hr time horizon... +2026-04-29 09:04:08,248 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:09,087 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 5 hr time horizon... +2026-04-29 09:04:09,110 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:10,362 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 8 hr time horizon... +2026-04-29 09:04:10,379 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:10,424 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 8 hr time horizon... +2026-04-29 09:04:10,443 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:11,001 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 18 hr time horizon... +2026-04-29 09:04:11,026 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:12,523 - __main__ - INFO - Finished processing 2018-01-02 09:00:00 1 hr time horizon... +2026-04-29 09:04:12,542 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:14,089 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 7 hr time horizon... +2026-04-29 09:04:14,113 - __main__ - INFO - Processing values: 2018-01-29 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:14,236 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 12 hr time horizon... +2026-04-29 09:04:14,261 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 3 hr time horizon... +2026-04-29 09:04:14,266 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 18 hr time horizon... +2026-04-29 09:04:14,291 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:15,059 - __main__ - INFO - Finished processing 2018-01-05 12:00:00 9 hr time horizon... +2026-04-29 09:04:15,080 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:15,718 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 13 hr time horizon... +2026-04-29 09:04:15,744 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:15,937 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 3 hr time horizon... +2026-04-29 09:04:15,961 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:16,425 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 1 hr time horizon... +2026-04-29 09:04:16,448 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:17,377 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 16 hr time horizon... +2026-04-29 09:04:17,399 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:19,122 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 11 hr time horizon... +2026-04-29 09:04:19,140 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:19,295 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 11 hr time horizon... +2026-04-29 09:04:19,318 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:20,187 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 3 hr time horizon... +2026-04-29 09:04:20,211 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:21,942 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 8 hr time horizon... +2026-04-29 09:04:21,967 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:22,874 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 12 hr time horizon... +2026-04-29 09:04:22,903 - __main__ - INFO - Processing values: 2018-01-09 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:23,334 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 2 hr time horizon... +2026-04-29 09:04:23,351 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:23,459 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 4 hr time horizon... +2026-04-29 09:04:23,482 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:24,985 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 3 hr time horizon... +2026-04-29 09:04:25,004 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:25,589 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 14 hr time horizon... +2026-04-29 09:04:25,611 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:25,972 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 17 hr time horizon... +2026-04-29 09:04:25,998 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:27,949 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 16 hr time horizon... +2026-04-29 09:04:27,975 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:28,341 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 3 hr time horizon... +2026-04-29 09:04:28,364 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:29,299 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 3 hr time horizon... +2026-04-29 09:04:29,331 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:29,708 - __main__ - INFO - Finished processing 2018-01-29 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:29,737 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:30,779 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 10 hr time horizon... +2026-04-29 09:04:30,800 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:31,013 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 9 hr time horizon... +2026-04-29 09:04:31,043 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:31,414 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 12 hr time horizon... +2026-04-29 09:04:31,439 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 1 hr time horizon... +2026-04-29 09:04:31,668 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 7 hr time horizon... +2026-04-29 09:04:31,695 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:32,815 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 13 hr time horizon... +2026-04-29 09:04:32,840 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:33,895 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:33,925 - __main__ - INFO - Processing values: 2018-01-03 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:34,942 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 7 hr time horizon... +2026-04-29 09:04:34,966 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:36,402 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 8 hr time horizon... +2026-04-29 09:04:36,425 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:37,098 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:37,120 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:04:38,216 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:38,244 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:39,366 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 10 hr time horizon... +2026-04-29 09:04:39,388 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:39,553 - __main__ - INFO - Finished processing 2018-01-09 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:39,582 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:41,080 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 17 hr time horizon... +2026-04-29 09:04:41,103 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:41,240 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 18 hr time horizon... +2026-04-29 09:04:41,266 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:41,401 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:41,422 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:42,401 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 10 hr time horizon... +2026-04-29 09:04:42,424 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:43,713 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 12 hr time horizon... +2026-04-29 09:04:43,739 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:43,886 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 14 hr time horizon... +2026-04-29 09:04:43,907 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:45,480 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 17 hr time horizon... +2026-04-29 09:04:45,506 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:45,819 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:45,842 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:45,959 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 11 hr time horizon... +2026-04-29 09:04:45,983 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:47,030 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 8 hr time horizon... +2026-04-29 09:04:47,058 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:47,177 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 1 hr time horizon... +2026-04-29 09:04:47,200 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 6 hr time horizon... +2026-04-29 09:04:47,257 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 17 hr time horizon... +2026-04-29 09:04:47,281 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:48,026 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 11 hr time horizon... +2026-04-29 09:04:48,048 - __main__ - INFO - Processing values: 2018-01-09 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:51,434 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 6 hr time horizon... +2026-04-29 09:04:51,455 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:52,889 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:52,915 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:54,658 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 1 hr time horizon... +2026-04-29 09:04:54,680 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:54,842 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 4 hr time horizon... +2026-04-29 09:04:54,870 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:55,266 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 9 hr time horizon... +2026-04-29 09:04:55,287 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:55,742 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 12 hr time horizon... +2026-04-29 09:04:55,765 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:56,386 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 7 hr time horizon... +2026-04-29 09:04:56,415 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:56,573 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 11 hr time horizon... +2026-04-29 09:04:56,595 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:57,040 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 14 hr time horizon... +2026-04-29 09:04:57,063 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:59,076 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 10 hr time horizon... +2026-04-29 09:04:59,098 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 6 hr time horizon... +2026-04-29 09:04:59,190 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 7 hr time horizon... +2026-04-29 09:04:59,221 - __main__ - INFO - Processing values: 2018-01-10 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:04:59,283 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 4 hr time horizon... +2026-04-29 09:04:59,314 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:01,411 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 14 hr time horizon... +2026-04-29 09:05:01,433 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:01,622 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 18 hr time horizon... +2026-04-29 09:05:01,642 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 10 hr time horizon... +2026-04-29 09:05:01,658 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 15 hr time horizon... +2026-04-29 09:05:01,680 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:03,391 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 15 hr time horizon... +2026-04-29 09:05:03,412 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 3 hr time horizon... +2026-04-29 09:05:03,498 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 10 hr time horizon... +2026-04-29 09:05:03,519 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:03,602 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 6 hr time horizon... +2026-04-29 09:05:03,628 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:05,324 - __main__ - INFO - Finished processing 2018-01-09 19:00:00 10 hr time horizon... +2026-04-29 09:05:05,349 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:05,534 - __main__ - INFO - Finished processing 2018-01-03 17:00:00 18 hr time horizon... +2026-04-29 09:05:05,557 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:07,282 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 14 hr time horizon... +2026-04-29 09:05:07,302 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:08,844 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 17 hr time horizon... +2026-04-29 09:05:08,864 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:10,384 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:10,407 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:11,037 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:11,059 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 15 hr time horizon... +2026-04-29 09:05:11,198 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:11,221 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:12,248 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 16 hr time horizon... +2026-04-29 09:05:12,283 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:12,437 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 1 hr time horizon... +2026-04-29 09:05:12,458 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:13,511 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 4 hr time horizon... +2026-04-29 09:05:13,535 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:14,441 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 1 hr time horizon... +2026-04-29 09:05:14,463 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:15,727 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 5 hr time horizon... +2026-04-29 09:05:15,748 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:15,934 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 6 hr time horizon... +2026-04-29 09:05:15,964 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:16,221 - __main__ - INFO - Finished processing 2018-01-10 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:16,244 - __main__ - INFO - Processing values: 2018-01-01 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:17,691 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 11 hr time horizon... +2026-04-29 09:05:17,716 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:17,905 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 10 hr time horizon... +2026-04-29 09:05:17,930 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:18,397 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 9 hr time horizon... +2026-04-29 09:05:18,420 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:19,530 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 11 hr time horizon... +2026-04-29 09:05:19,552 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:20,165 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 3 hr time horizon... +2026-04-29 09:05:20,194 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:20,499 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 9 hr time horizon... +2026-04-29 09:05:20,527 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:22,726 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:22,750 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 14 hr time horizon... +2026-04-29 09:05:22,909 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 10 hr time horizon... +2026-04-29 09:05:22,932 - __main__ - INFO - Processing values: 2018-01-29 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:24,884 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 18 hr time horizon... +2026-04-29 09:05:24,910 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:27,053 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 9 hr time horizon... +2026-04-29 09:05:27,086 - __main__ - INFO - Processing values: 2018-01-28 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:27,383 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 14 hr time horizon... +2026-04-29 09:05:27,410 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:27,827 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:27,849 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:28,006 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 15 hr time horizon... +2026-04-29 09:05:28,035 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:28,671 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:28,696 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:28,945 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 12 hr time horizon... +2026-04-29 09:05:28,972 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:30,013 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 14 hr time horizon... +2026-04-29 09:05:30,035 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:31,084 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:31,106 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:31,774 - __main__ - INFO - Finished processing 2018-01-01 21:00:00 1 hr time horizon... +2026-04-29 09:05:31,793 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:32,381 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 5 hr time horizon... +2026-04-29 09:05:32,415 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:32,526 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 5 hr time horizon... +2026-04-29 09:05:32,550 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:33,713 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 5 hr time horizon... +2026-04-29 09:05:33,734 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:33,812 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 7 hr time horizon... +2026-04-29 09:05:33,839 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:35,810 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 15 hr time horizon... +2026-04-29 09:05:35,830 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:36,183 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 1 hr time horizon... +2026-04-29 09:05:36,200 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 6 hr time horizon... +2026-04-29 09:05:36,308 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 14 hr time horizon... +2026-04-29 09:05:36,331 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 5 hr time horizon... +2026-04-29 09:05:36,389 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 14 hr time horizon... +2026-04-29 09:05:36,415 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:38,841 - __main__ - INFO - Finished processing 2018-01-29 06:00:00 4 hr time horizon... +2026-04-29 09:05:38,861 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:39,994 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 14 hr time horizon... +2026-04-29 09:05:40,015 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 1 hr time horizon... +2026-04-29 09:05:40,125 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 7 hr time horizon... +2026-04-29 09:05:40,144 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:42,584 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 13 hr time horizon... +2026-04-29 09:05:42,604 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:42,900 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 9 hr time horizon... +2026-04-29 09:05:42,925 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:43,374 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 11 hr time horizon... +2026-04-29 09:05:43,394 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 10 hr time horizon... +2026-04-29 09:05:43,477 - __main__ - INFO - Finished processing 2018-01-28 12:00:00 11 hr time horizon... +2026-04-29 09:05:43,495 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:44,311 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 16 hr time horizon... +2026-04-29 09:05:44,338 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:44,735 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 3 hr time horizon... +2026-04-29 09:05:44,760 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:47,012 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 8 hr time horizon... +2026-04-29 09:05:47,033 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:47,378 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 17 hr time horizon... +2026-04-29 09:05:47,401 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:47,657 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:47,679 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:48,424 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 4 hr time horizon... +2026-04-29 09:05:48,446 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:48,742 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 2 hr time horizon... +2026-04-29 09:05:48,763 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:49,061 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 18 hr time horizon... +2026-04-29 09:05:49,082 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:50,619 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 10 hr time horizon... +2026-04-29 09:05:50,641 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 4 hr time horizon... +2026-04-29 09:05:50,762 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 5 hr time horizon... +2026-04-29 09:05:50,784 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 3 hr time horizon... +2026-04-29 09:05:50,878 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:50,896 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 15 hr time horizon... +2026-04-29 09:05:50,966 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 2 hr time horizon... +2026-04-29 09:05:50,992 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:51,912 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 12 hr time horizon... +2026-04-29 09:05:51,932 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:53,852 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 4 hr time horizon... +2026-04-29 09:05:53,872 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:55,415 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 12 hr time horizon... +2026-04-29 09:05:55,439 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:57,558 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 4 hr time horizon... +2026-04-29 09:05:57,588 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:57,743 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 1 hr time horizon... +2026-04-29 09:05:57,765 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:57,883 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 1 hr time horizon... +2026-04-29 09:05:57,910 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:58,224 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 10 hr time horizon... +2026-04-29 09:05:58,250 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:05:59,192 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 1 hr time horizon... +2026-04-29 09:05:59,214 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:00,039 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 10 hr time horizon... +2026-04-29 09:06:00,060 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:01,438 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 16 hr time horizon... +2026-04-29 09:06:01,474 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:02,846 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:02,873 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:03,413 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 15 hr time horizon... +2026-04-29 09:06:03,440 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:03,985 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 9 hr time horizon... +2026-04-29 09:06:04,014 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:04,023 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 11 hr time horizon... +2026-04-29 09:06:04,055 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:04,623 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 16 hr time horizon... +2026-04-29 09:06:04,643 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:05,679 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 3 hr time horizon... +2026-04-29 09:06:05,705 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:05,722 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 18 hr time horizon... +2026-04-29 09:06:05,745 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:05,819 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 4 hr time horizon... +2026-04-29 09:06:05,839 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:07,141 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 15 hr time horizon... +2026-04-29 09:06:07,166 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:07,438 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 6 hr time horizon... +2026-04-29 09:06:07,463 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:09,435 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 2 hr time horizon... +2026-04-29 09:06:09,459 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:10,386 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 4 hr time horizon... +2026-04-29 09:06:10,407 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:11,731 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 4 hr time horizon... +2026-04-29 09:06:11,758 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:12,187 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 4 hr time horizon... +2026-04-29 09:06:12,206 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:13,388 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 3 hr time horizon... +2026-04-29 09:06:13,408 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 12 hr time horizon... +2026-04-29 09:06:13,553 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 13 hr time horizon... +2026-04-29 09:06:13,577 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:15,852 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 6 hr time horizon... +2026-04-29 09:06:15,873 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:17,547 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 3 hr time horizon... +2026-04-29 09:06:17,572 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:17,686 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 3 hr time horizon... +2026-04-29 09:06:17,716 - __main__ - INFO - Processing values: 2018-01-02 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:18,939 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 7 hr time horizon... +2026-04-29 09:06:18,966 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:19,732 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:19,754 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:19,868 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 3 hr time horizon... +2026-04-29 09:06:19,890 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:20,373 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 6 hr time horizon... +2026-04-29 09:06:20,395 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:20,475 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 18 hr time horizon... +2026-04-29 09:06:20,496 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:21,031 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:21,058 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:21,847 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 7 hr time horizon... +2026-04-29 09:06:21,873 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:23,178 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 15 hr time horizon... +2026-04-29 09:06:23,205 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 15 hr time horizon... +2026-04-29 09:06:23,254 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:23,280 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 13 hr time horizon... +2026-04-29 09:06:23,407 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 10 hr time horizon... +2026-04-29 09:06:23,431 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:23,680 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 9 hr time horizon... +2026-04-29 09:06:23,701 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:26,031 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:26,054 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:28,297 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:28,321 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:29,016 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 1 hr time horizon... +2026-04-29 09:06:29,043 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:30,161 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 8 hr time horizon... +2026-04-29 09:06:30,182 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:31,163 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 16 hr time horizon... +2026-04-29 09:06:31,185 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:31,724 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 18 hr time horizon... +2026-04-29 09:06:31,745 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:32,295 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 12 hr time horizon... +2026-04-29 09:06:32,325 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:35,102 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:35,126 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:35,417 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 4 hr time horizon... +2026-04-29 09:06:35,438 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:35,989 - __main__ - INFO - Finished processing 2018-01-02 00:00:00 10 hr time horizon... +2026-04-29 09:06:36,009 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 4 hr time horizon... +2026-04-29 09:06:36,027 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 8 hr time horizon... +2026-04-29 09:06:36,049 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 11 hr time horizon... +2026-04-29 09:06:36,174 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 12 hr time horizon... +2026-04-29 09:06:36,195 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:36,412 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 6 hr time horizon... +2026-04-29 09:06:36,436 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 1 hr time horizon... +2026-04-29 09:06:36,622 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 12 hr time horizon... +2026-04-29 09:06:36,647 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:39,340 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 15 hr time horizon... +2026-04-29 09:06:39,359 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:39,853 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 13 hr time horizon... +2026-04-29 09:06:39,877 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 4 hr time horizon... +2026-04-29 09:06:39,883 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 10 hr time horizon... +2026-04-29 09:06:39,904 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:39,988 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 14 hr time horizon... +2026-04-29 09:06:40,013 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:40,412 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 14 hr time horizon... +2026-04-29 09:06:40,438 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:41,648 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 1 hr time horizon... +2026-04-29 09:06:41,669 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:42,554 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 17 hr time horizon... +2026-04-29 09:06:42,576 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:43,891 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 13 hr time horizon... +2026-04-29 09:06:43,914 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:44,536 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 14 hr time horizon... +2026-04-29 09:06:44,558 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:45,521 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 14 hr time horizon... +2026-04-29 09:06:45,541 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:45,930 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 10 hr time horizon... +2026-04-29 09:06:45,955 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:46,444 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 1 hr time horizon... +2026-04-29 09:06:46,462 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:49,399 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 11 hr time horizon... +2026-04-29 09:06:49,423 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:50,048 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 4 hr time horizon... +2026-04-29 09:06:50,067 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:50,214 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:50,238 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 12 hr time horizon... +2026-04-29 09:06:50,327 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 12 hr time horizon... +2026-04-29 09:06:50,348 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:50,598 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 10 hr time horizon... +2026-04-29 09:06:50,617 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 1 hr time horizon... +2026-04-29 09:06:50,739 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 1 hr time horizon... +2026-04-29 09:06:50,758 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:51,166 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 12 hr time horizon... +2026-04-29 09:06:51,185 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:54,086 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 11 hr time horizon... +2026-04-29 09:06:54,111 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:54,195 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:54,213 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:54,667 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 11 hr time horizon... +2026-04-29 09:06:54,693 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:54,703 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 18 hr time horizon... +2026-04-29 09:06:54,729 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:56,082 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 4 hr time horizon... +2026-04-29 09:06:56,103 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:56,677 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 18 hr time horizon... +2026-04-29 09:06:56,698 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 2 hr time horizon... +2026-04-29 09:06:56,701 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 9 hr time horizon... +2026-04-29 09:06:56,721 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:57,612 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:57,635 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:58,647 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 14 hr time horizon... +2026-04-29 09:06:58,672 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:06:59,574 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 1 hr time horizon... +2026-04-29 09:06:59,595 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:00,844 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 5 hr time horizon... +2026-04-29 09:07:00,865 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:00,961 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 18 hr time horizon... +2026-04-29 09:07:00,986 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:03,624 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 11 hr time horizon... +2026-04-29 09:07:03,645 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:05,006 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 12 hr time horizon... +2026-04-29 09:07:05,031 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:05,504 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 1 hr time horizon... +2026-04-29 09:07:05,524 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:05,665 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 5 hr time horizon... +2026-04-29 09:07:05,688 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:05,722 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 1 hr time horizon... +2026-04-29 09:07:05,742 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 17 hr time horizon... +2026-04-29 09:07:06,041 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 13 hr time horizon... +2026-04-29 09:07:06,062 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:06,223 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 5 hr time horizon... +2026-04-29 09:07:06,244 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:07,439 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 8 hr time horizon... +2026-04-29 09:07:07,462 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:09,594 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:09,618 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:10,453 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:10,475 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:11,925 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:11,945 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:12,667 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 5 hr time horizon... +2026-04-29 09:07:12,716 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:13,027 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 12 hr time horizon... +2026-04-29 09:07:13,051 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:13,246 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 2 hr time horizon... +2026-04-29 09:07:13,273 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:13,340 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 2 hr time horizon... +2026-04-29 09:07:13,367 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:13,956 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:13,978 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:14,995 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 13 hr time horizon... +2026-04-29 09:07:15,033 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 5 hr time horizon... +2026-04-29 09:07:15,199 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 1 hr time horizon... +2026-04-29 09:07:15,227 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:17,734 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 6 hr time horizon... +2026-04-29 09:07:17,762 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 8 hr time horizon... +2026-04-29 09:07:17,859 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 18 hr time horizon... +2026-04-29 09:07:17,883 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:18,941 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 1 hr time horizon... +2026-04-29 09:07:18,967 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:21,540 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 7 hr time horizon... +2026-04-29 09:07:21,567 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:21,851 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 4 hr time horizon... +2026-04-29 09:07:21,871 - __main__ - INFO - Processing values: 2018-01-24 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:22,176 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:22,200 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 13 hr time horizon... +2026-04-29 09:07:22,344 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:22,366 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 2 hr time horizon... +2026-04-29 09:07:22,390 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 13 hr time horizon... +2026-04-29 09:07:22,414 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:23,607 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 14 hr time horizon... +2026-04-29 09:07:23,631 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:24,131 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 17 hr time horizon... +2026-04-29 09:07:24,157 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:25,482 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 3 hr time horizon... +2026-04-29 09:07:25,505 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:26,592 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 9 hr time horizon... +2026-04-29 09:07:26,614 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:27,697 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:27,721 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:28,656 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 2 hr time horizon... +2026-04-29 09:07:28,682 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:28,793 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 15 hr time horizon... +2026-04-29 09:07:28,824 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:29,587 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:29,609 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:29,745 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 8 hr time horizon... +2026-04-29 09:07:29,770 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:30,262 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 4 hr time horizon... +2026-04-29 09:07:30,283 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:31,400 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 5 hr time horizon... +2026-04-29 09:07:31,420 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:31,588 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 5 hr time horizon... +2026-04-29 09:07:31,615 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:33,853 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 5 hr time horizon... +2026-04-29 09:07:33,871 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:34,176 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 8 hr time horizon... +2026-04-29 09:07:34,201 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 9 hr time horizon... +2026-04-29 09:07:34,575 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 1 hr time horizon... +2026-04-29 09:07:34,595 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:37,618 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 2 hr time horizon... +2026-04-29 09:07:37,642 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:37,767 - __main__ - INFO - Finished processing 2018-01-24 20:00:00 15 hr time horizon... +2026-04-29 09:07:37,797 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:38,283 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 1 hr time horizon... +2026-04-29 09:07:38,307 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:38,505 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 13 hr time horizon... +2026-04-29 09:07:38,527 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:39,130 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 17 hr time horizon... +2026-04-29 09:07:39,156 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 5 hr time horizon... +2026-04-29 09:07:39,343 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:39,365 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:41,102 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 7 hr time horizon... +2026-04-29 09:07:41,125 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:42,453 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 11 hr time horizon... +2026-04-29 09:07:42,482 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:43,206 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 14 hr time horizon... +2026-04-29 09:07:43,230 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:44,196 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 10 hr time horizon... +2026-04-29 09:07:44,220 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:44,384 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 15 hr time horizon... +2026-04-29 09:07:44,410 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:44,582 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:44,606 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:45,803 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 15 hr time horizon... +2026-04-29 09:07:45,825 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:46,379 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 17 hr time horizon... +2026-04-29 09:07:46,403 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 17 hr time horizon... +2026-04-29 09:07:46,406 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 4 hr time horizon... +2026-04-29 09:07:46,427 - __main__ - INFO - Processing values: 2018-01-22 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:47,588 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 7 hr time horizon... +2026-04-29 09:07:47,607 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:49,409 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 6 hr time horizon... +2026-04-29 09:07:49,432 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:49,660 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 9 hr time horizon... +2026-04-29 09:07:49,681 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:50,207 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:50,228 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:52,820 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 9 hr time horizon... +2026-04-29 09:07:52,843 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:52,983 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 7 hr time horizon... +2026-04-29 09:07:53,003 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:53,254 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 1 hr time horizon... +2026-04-29 09:07:53,275 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:53,654 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 5 hr time horizon... +2026-04-29 09:07:53,671 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:53,747 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 15 hr time horizon... +2026-04-29 09:07:53,773 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:54,462 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:54,486 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:55,679 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 14 hr time horizon... +2026-04-29 09:07:55,703 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:57,456 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 1 hr time horizon... +2026-04-29 09:07:57,480 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:58,394 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:58,414 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:58,689 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 8 hr time horizon... +2026-04-29 09:07:58,712 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:07:59,576 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 8 hr time horizon... +2026-04-29 09:07:59,597 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:00,293 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:00,314 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:00,708 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 17 hr time horizon... +2026-04-29 09:08:00,729 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 14 hr time horizon... +2026-04-29 09:08:00,855 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:00,876 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:01,628 - __main__ - INFO - Finished processing 2018-01-22 22:00:00 15 hr time horizon... +2026-04-29 09:08:01,649 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:03,061 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 10 hr time horizon... +2026-04-29 09:08:03,082 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:04,143 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 4 hr time horizon... +2026-04-29 09:08:04,145 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 7 hr time horizon... +2026-04-29 09:08:04,181 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 2 hr time horizon... +2026-04-29 09:08:04,184 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 14 hr time horizon... +2026-04-29 09:08:04,288 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 12 hr time horizon... +2026-04-29 09:08:04,309 - __main__ - INFO - Processing values: 2018-01-22 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:07,557 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:07,584 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:07,814 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 4 hr time horizon... +2026-04-29 09:08:07,839 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:08,078 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 15 hr time horizon... +2026-04-29 09:08:08,100 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:08,753 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 8 hr time horizon... +2026-04-29 09:08:08,786 - __main__ - INFO - Processing values: 2018-01-15 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:08,974 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 9 hr time horizon... +2026-04-29 09:08:09,023 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:09,327 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 1 hr time horizon... +2026-04-29 09:08:09,344 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:10,295 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:10,316 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:11,686 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 13 hr time horizon... +2026-04-29 09:08:11,710 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:12,305 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 8 hr time horizon... +2026-04-29 09:08:12,325 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:14,161 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 4 hr time horizon... +2026-04-29 09:08:14,189 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:14,264 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 11 hr time horizon... +2026-04-29 09:08:14,287 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:15,843 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 14 hr time horizon... +2026-04-29 09:08:15,877 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:16,459 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 8 hr time horizon... +2026-04-29 09:08:16,482 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:16,716 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 14 hr time horizon... +2026-04-29 09:08:16,741 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:17,767 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 11 hr time horizon... +2026-04-29 09:08:17,805 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:18,809 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:18,831 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 11 hr time horizon... +2026-04-29 09:08:18,932 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 5 hr time horizon... +2026-04-29 09:08:18,954 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:19,467 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 2 hr time horizon... +2026-04-29 09:08:19,488 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:19,706 - __main__ - INFO - Finished processing 2018-01-22 22:00:00 11 hr time horizon... +2026-04-29 09:08:19,728 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 12 hr time horizon... +2026-04-29 09:08:20,294 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 14 hr time horizon... +2026-04-29 09:08:20,319 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:23,987 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 1 hr time horizon... +2026-04-29 09:08:24,011 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:24,084 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 1 hr time horizon... +2026-04-29 09:08:24,112 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:24,169 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 1 hr time horizon... +2026-04-29 09:08:24,189 - __main__ - INFO - Processing values: 2018-01-26 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:24,658 - __main__ - INFO - Finished processing 2018-01-15 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:24,682 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:25,270 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 2 hr time horizon... +2026-04-29 09:08:25,293 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:26,162 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 8 hr time horizon... +2026-04-29 09:08:26,183 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:27,564 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 14 hr time horizon... +2026-04-29 09:08:27,587 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:28,234 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 9 hr time horizon... +2026-04-29 09:08:28,255 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:29,026 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 13 hr time horizon... +2026-04-29 09:08:29,051 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:30,810 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 14 hr time horizon... +2026-04-29 09:08:30,831 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:31,124 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 14 hr time horizon... +2026-04-29 09:08:31,148 - __main__ - INFO - Processing values: 2018-01-11 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:08:31,796 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:31,824 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:32,670 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 2 hr time horizon... +2026-04-29 09:08:32,691 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:33,210 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 12 hr time horizon... +2026-04-29 09:08:33,240 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:33,980 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 7 hr time horizon... +2026-04-29 09:08:34,006 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:35,043 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 11 hr time horizon... +2026-04-29 09:08:35,066 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:35,315 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 12 hr time horizon... +2026-04-29 09:08:35,340 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:36,088 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 13 hr time horizon... +2026-04-29 09:08:36,110 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 11 hr time horizon... +2026-04-29 09:08:36,275 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 15 hr time horizon... +2026-04-29 09:08:36,296 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:39,856 - __main__ - INFO - Finished processing 2018-01-26 15:00:00 8 hr time horizon... +2026-04-29 09:08:39,880 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:40,527 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 3 hr time horizon... +2026-04-29 09:08:40,553 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:40,755 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 9 hr time horizon... +2026-04-29 09:08:40,777 - __main__ - INFO - Processing values: 2018-01-14 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:41,100 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 4 hr time horizon... +2026-04-29 09:08:41,122 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:41,248 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 1 hr time horizon... +2026-04-29 09:08:41,269 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:42,936 - __main__ - INFO - Finished processing 2018-01-01 23:00:00 3 hr time horizon... +2026-04-29 09:08:42,965 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:43,627 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 16 hr time horizon... +2026-04-29 09:08:43,650 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:44,229 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 2 hr time horizon... +2026-04-29 09:08:44,249 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:44,693 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 14 hr time horizon... +2026-04-29 09:08:44,723 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:47,128 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:47,158 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:47,231 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 5 hr time horizon... +2026-04-29 09:08:47,251 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:47,936 - __main__ - INFO - Finished processing 2018-01-11 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:47,961 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:48,163 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 10 hr time horizon... +2026-04-29 09:08:48,186 - __main__ - INFO - Processing values: 2018-01-07 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:48,625 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 5 hr time horizon... +2026-04-29 09:08:48,648 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:48,859 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 18 hr time horizon... +2026-04-29 09:08:48,886 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:50,618 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:50,639 - __main__ - INFO - Processing values: 2018-01-15 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:51,281 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 14 hr time horizon... +2026-04-29 09:08:51,305 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:51,947 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 11 hr time horizon... +2026-04-29 09:08:51,967 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:52,198 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 9 hr time horizon... +2026-04-29 09:08:52,221 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 6 hr time horizon... +2026-04-29 09:08:52,768 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 17 hr time horizon... +2026-04-29 09:08:52,791 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:56,320 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 9 hr time horizon... +2026-04-29 09:08:56,343 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:57,646 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 5 hr time horizon... +2026-04-29 09:08:57,649 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 1 hr time horizon... +2026-04-29 09:08:57,672 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 8 hr time horizon... +2026-04-29 09:08:57,673 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:58,482 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 4 hr time horizon... +2026-04-29 09:08:58,502 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:08:59,243 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 15 hr time horizon... +2026-04-29 09:08:59,267 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:00,045 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 15 hr time horizon... +2026-04-29 09:09:00,073 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:00,249 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 3 hr time horizon... +2026-04-29 09:09:00,268 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:02,381 - __main__ - INFO - Finished processing 2018-01-07 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:02,402 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:02,515 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 11 hr time horizon... +2026-04-29 09:09:02,534 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:02,920 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 1 hr time horizon... +2026-04-29 09:09:02,937 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:03,031 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 15 hr time horizon... +2026-04-29 09:09:03,053 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:03,461 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 2 hr time horizon... +2026-04-29 09:09:03,479 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:03,633 - __main__ - INFO - Finished processing 2018-01-14 09:00:00 5 hr time horizon... +2026-04-29 09:09:03,651 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:05,880 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 6 hr time horizon... +2026-04-29 09:09:05,898 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 6 hr time horizon... +2026-04-29 09:09:06,326 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 16 hr time horizon... +2026-04-29 09:09:06,345 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:09,783 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 17 hr time horizon... +2026-04-29 09:09:09,803 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:17,755 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 3 hr time horizon... +2026-04-29 09:09:17,773 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 4 hr time horizon... +2026-04-29 09:09:18,120 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 10 hr time horizon... +2026-04-29 09:09:18,138 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:20,856 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 9 hr time horizon... +2026-04-29 09:09:20,874 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:23,073 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 6 hr time horizon... +2026-04-29 09:09:23,090 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:24,651 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 8 hr time horizon... +2026-04-29 09:09:24,670 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:24,742 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 15 hr time horizon... +2026-04-29 09:09:24,763 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:25,718 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 8 hr time horizon... +2026-04-29 09:09:25,735 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:25,972 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 15 hr time horizon... +2026-04-29 09:09:25,989 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:27,826 - __main__ - INFO - Finished processing 2018-01-15 16:00:00 10 hr time horizon... +2026-04-29 09:09:27,843 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:30,524 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:30,547 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:30,902 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 2 hr time horizon... +2026-04-29 09:09:30,918 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:32,727 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 1 hr time horizon... +2026-04-29 09:09:32,742 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 18 hr time horizon... +2026-04-29 09:09:33,269 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 7 hr time horizon... +2026-04-29 09:09:33,286 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:37,054 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 16 hr time horizon... +2026-04-29 09:09:37,076 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:37,202 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 10 hr time horizon... +2026-04-29 09:09:37,220 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:38,766 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 17 hr time horizon... +2026-04-29 09:09:38,786 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:39,401 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:39,422 - __main__ - INFO - Processing values: 2018-01-11 12:00:00 5 hr time horizon... +2026-04-29 09:09:39,565 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 17 hr time horizon... +2026-04-29 09:09:39,587 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:40,358 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 1 hr time horizon... +2026-04-29 09:09:40,378 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:40,893 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 10 hr time horizon... +2026-04-29 09:09:40,911 - __main__ - INFO - Processing values: 2018-01-09 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:42,954 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 7 hr time horizon... +2026-04-29 09:09:42,973 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:43,427 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 7 hr time horizon... +2026-04-29 09:09:43,450 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:45,434 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 18 hr time horizon... +2026-04-29 09:09:45,454 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 18 hr time horizon... +2026-04-29 09:09:45,823 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 3 hr time horizon... +2026-04-29 09:09:45,842 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:50,072 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 17 hr time horizon... +2026-04-29 09:09:50,091 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:50,350 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:50,368 - __main__ - INFO - Processing values: 2018-01-17 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:50,958 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 5 hr time horizon... +2026-04-29 09:09:50,975 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:51,303 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 15 hr time horizon... +2026-04-29 09:09:51,324 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:51,813 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 1 hr time horizon... +2026-04-29 09:09:51,833 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:53,036 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 13 hr time horizon... +2026-04-29 09:09:53,058 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:53,194 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:53,217 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:53,914 - __main__ - INFO - Finished processing 2018-01-11 12:00:00 5 hr time horizon... +2026-04-29 09:09:53,939 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:54,645 - __main__ - INFO - Finished processing 2018-01-09 06:00:00 18 hr time horizon... +2026-04-29 09:09:54,666 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:55,241 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 9 hr time horizon... +2026-04-29 09:09:55,262 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:56,413 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 3 hr time horizon... +2026-04-29 09:09:56,432 - __main__ - INFO - Processing values: 2018-01-07 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:09:59,578 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 14 hr time horizon... +2026-04-29 09:09:59,599 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:03,845 - __main__ - INFO - Finished processing 2018-01-17 09:00:00 14 hr time horizon... +2026-04-29 09:10:03,864 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:03,958 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 16 hr time horizon... +2026-04-29 09:10:03,978 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:04,286 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 18 hr time horizon... +2026-04-29 09:10:04,309 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:05,338 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 18 hr time horizon... +2026-04-29 09:10:05,362 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:06,182 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 18 hr time horizon... +2026-04-29 09:10:06,210 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:08,123 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 2 hr time horizon... +2026-04-29 09:10:08,145 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:08,303 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 12 hr time horizon... +2026-04-29 09:10:08,328 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:08,592 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 16 hr time horizon... +2026-04-29 09:10:08,612 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 7 hr time horizon... +2026-04-29 09:10:08,784 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 8 hr time horizon... +2026-04-29 09:10:08,806 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:09,025 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:09,045 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:09,526 - __main__ - INFO - Finished processing 2018-01-07 15:00:00 10 hr time horizon... +2026-04-29 09:10:09,551 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:11,446 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:11,468 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:12,547 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 7 hr time horizon... +2026-04-29 09:10:12,568 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:13,905 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 3 hr time horizon... +2026-04-29 09:10:13,928 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:16,911 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 7 hr time horizon... +2026-04-29 09:10:16,934 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:17,758 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 14 hr time horizon... +2026-04-29 09:10:17,781 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:18,466 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 17 hr time horizon... +2026-04-29 09:10:18,488 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:20,568 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:20,592 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:21,441 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 15 hr time horizon... +2026-04-29 09:10:21,462 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 16 hr time horizon... +2026-04-29 09:10:21,492 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 7 hr time horizon... +2026-04-29 09:10:21,512 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:21,698 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 1 hr time horizon... +2026-04-29 09:10:21,719 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 3 hr time horizon... +2026-04-29 09:10:21,763 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:21,784 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:21,895 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 8 hr time horizon... +2026-04-29 09:10:21,917 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:22,378 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 7 hr time horizon... +2026-04-29 09:10:22,398 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:22,748 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 7 hr time horizon... +2026-04-29 09:10:22,770 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:22,924 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 9 hr time horizon... +2026-04-29 09:10:22,942 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:25,209 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:25,235 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:25,405 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 14 hr time horizon... +2026-04-29 09:10:25,428 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:25,950 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 16 hr time horizon... +2026-04-29 09:10:25,969 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:27,095 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 14 hr time horizon... +2026-04-29 09:10:27,116 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:30,274 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:30,294 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:30,775 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 6 hr time horizon... +2026-04-29 09:10:30,793 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:32,958 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 17 hr time horizon... +2026-04-29 09:10:32,979 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:34,644 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 2 hr time horizon... +2026-04-29 09:10:34,677 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:10:35,451 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:35,475 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:35,776 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 16 hr time horizon... +2026-04-29 09:10:35,797 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:35,880 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 3 hr time horizon... +2026-04-29 09:10:35,898 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,149 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 18 hr time horizon... +2026-04-29 09:10:36,171 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,271 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 16 hr time horizon... +2026-04-29 09:10:36,299 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 6 hr time horizon... +2026-04-29 09:10:36,380 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 11 hr time horizon... +2026-04-29 09:10:36,403 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,466 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,494 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 15 hr time horizon... +2026-04-29 09:10:36,709 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,732 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:36,828 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 17 hr time horizon... +2026-04-29 09:10:36,854 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:38,836 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 11 hr time horizon... +2026-04-29 09:10:38,855 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:39,071 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 17 hr time horizon... +2026-04-29 09:10:39,099 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:40,100 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 18 hr time horizon... +2026-04-29 09:10:40,118 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:40,985 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 18 hr time horizon... +2026-04-29 09:10:41,007 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:45,790 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:45,815 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:46,816 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 9 hr time horizon... +2026-04-29 09:10:46,840 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:48,413 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 9 hr time horizon... +2026-04-29 09:10:48,436 - __main__ - INFO - Processing values: 2018-01-20 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:49,758 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 13 hr time horizon... +2026-04-29 09:10:49,785 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:49,985 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 5 hr time horizon... +2026-04-29 09:10:50,015 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:50,759 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 14 hr time horizon... +2026-04-29 09:10:50,789 - __main__ - INFO - Processing values: 2018-01-21 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:50,866 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 6 hr time horizon... +2026-04-29 09:10:50,886 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:51,030 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 1 hr time horizon... +2026-04-29 09:10:51,061 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:51,091 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 3 hr time horizon... +2026-04-29 09:10:51,112 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:51,779 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 5 hr time horizon... +2026-04-29 09:10:51,800 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:52,684 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 6 hr time horizon... +2026-04-29 09:10:52,712 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:53,099 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 15 hr time horizon... +2026-04-29 09:10:53,126 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:53,208 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 7 hr time horizon... +2026-04-29 09:10:53,231 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:54,456 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:54,477 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:54,521 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 6 hr time horizon... +2026-04-29 09:10:54,546 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:55,369 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 13 hr time horizon... +2026-04-29 09:10:55,396 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:56,302 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 11 hr time horizon... +2026-04-29 09:10:56,312 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 10 hr time horizon... +2026-04-29 09:10:56,328 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 4 hr time horizon... +2026-04-29 09:10:56,337 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:56,897 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 12 hr time horizon... +2026-04-29 09:10:56,923 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:10:57,843 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 10 hr time horizon... +2026-04-29 09:10:57,865 - __main__ - INFO - Processing values: 2018-01-13 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:02,212 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 8 hr time horizon... +2026-04-29 09:11:02,236 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:03,201 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:03,231 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:04,344 - __main__ - INFO - Finished processing 2018-01-20 18:00:00 15 hr time horizon... +2026-04-29 09:11:04,364 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:05,028 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 4 hr time horizon... +2026-04-29 09:11:05,038 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 9 hr time horizon... +2026-04-29 09:11:05,052 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 12 hr time horizon... +2026-04-29 09:11:05,061 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:06,026 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 18 hr time horizon... +2026-04-29 09:11:06,034 - __main__ - INFO - Finished processing 2018-01-21 07:00:00 18 hr time horizon... +2026-04-29 09:11:06,052 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 1 hr time horizon... +2026-04-29 09:11:06,063 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 2 hr time horizon... +2026-04-29 09:11:06,069 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 17 hr time horizon... +2026-04-29 09:11:06,093 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 4 hr time horizon... +2026-04-29 09:11:06,160 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 8 hr time horizon... +2026-04-29 09:11:06,185 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:06,475 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 10 hr time horizon... +2026-04-29 09:11:06,495 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:08,146 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 2 hr time horizon... +2026-04-29 09:11:08,165 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:09,032 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 9 hr time horizon... +2026-04-29 09:11:09,052 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:09,649 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 6 hr time horizon... +2026-04-29 09:11:09,677 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:09,723 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 3 hr time horizon... +2026-04-29 09:11:09,743 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 13 hr time horizon... +2026-04-29 09:11:10,194 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 5 hr time horizon... +2026-04-29 09:11:10,215 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 18 hr time horizon... +2026-04-29 09:11:10,318 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 9 hr time horizon... +2026-04-29 09:11:10,341 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:16,637 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 13 hr time horizon... +2026-04-29 09:11:16,658 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:17,605 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 15 hr time horizon... +2026-04-29 09:11:17,626 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:18,614 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 7 hr time horizon... +2026-04-29 09:11:18,636 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:18,793 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:18,817 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:19,314 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:19,332 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:20,336 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 4 hr time horizon... +2026-04-29 09:11:20,359 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:21,013 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 2 hr time horizon... +2026-04-29 09:11:21,031 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:22,140 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 12 hr time horizon... +2026-04-29 09:11:22,159 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:22,331 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 10 hr time horizon... +2026-04-29 09:11:22,335 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:22,365 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 6 hr time horizon... +2026-04-29 09:11:22,366 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:22,980 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:23,011 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:23,088 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 7 hr time horizon... +2026-04-29 09:11:23,110 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 10 hr time horizon... +2026-04-29 09:11:23,136 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 13 hr time horizon... +2026-04-29 09:11:23,158 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:24,288 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 16 hr time horizon... +2026-04-29 09:11:24,313 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:25,308 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 18 hr time horizon... +2026-04-29 09:11:25,329 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:26,190 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 5 hr time horizon... +2026-04-29 09:11:26,210 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:30,966 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 1 hr time horizon... +2026-04-29 09:11:30,985 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:32,608 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 9 hr time horizon... +2026-04-29 09:11:32,632 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:32,688 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 9 hr time horizon... +2026-04-29 09:11:32,708 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:34,036 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 7 hr time horizon... +2026-04-29 09:11:34,061 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:34,180 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 6 hr time horizon... +2026-04-29 09:11:34,200 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:34,956 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 3 hr time horizon... +2026-04-29 09:11:34,980 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:35,349 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:35,383 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:36,442 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 17 hr time horizon... +2026-04-29 09:11:36,467 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 5 hr time horizon... +2026-04-29 09:11:36,467 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 6 hr time horizon... +2026-04-29 09:11:36,499 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:37,194 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 10 hr time horizon... +2026-04-29 09:11:37,213 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:37,485 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 15 hr time horizon... +2026-04-29 09:11:37,505 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:37,634 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 6 hr time horizon... +2026-04-29 09:11:37,654 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 14 hr time horizon... +2026-04-29 09:11:37,677 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 16 hr time horizon... +2026-04-29 09:11:37,699 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:38,753 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 12 hr time horizon... +2026-04-29 09:11:38,773 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:42,449 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 10 hr time horizon... +2026-04-29 09:11:42,469 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 15 hr time horizon... +2026-04-29 09:11:42,637 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:42,656 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:43,614 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 16 hr time horizon... +2026-04-29 09:11:43,632 - __main__ - INFO - Processing values: 2018-01-17 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:44,674 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 16 hr time horizon... +2026-04-29 09:11:44,696 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:46,171 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 1 hr time horizon... +2026-04-29 09:11:46,188 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:46,752 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 2 hr time horizon... +2026-04-29 09:11:46,773 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:47,356 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 12 hr time horizon... +2026-04-29 09:11:47,384 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:49,140 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 7 hr time horizon... +2026-04-29 09:11:49,159 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:49,516 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 5 hr time horizon... +2026-04-29 09:11:49,536 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:50,468 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 12 hr time horizon... +2026-04-29 09:11:50,489 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:50,849 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 14 hr time horizon... +2026-04-29 09:11:50,874 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 17 hr time horizon... +2026-04-29 09:11:50,994 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:51,023 - __main__ - INFO - Processing values: 2018-01-17 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:51,146 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 12 hr time horizon... +2026-04-29 09:11:51,170 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:52,082 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 14 hr time horizon... +2026-04-29 09:11:52,104 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:52,902 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 12 hr time horizon... +2026-04-29 09:11:52,925 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:53,678 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 13 hr time horizon... +2026-04-29 09:11:53,699 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:56,489 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 6 hr time horizon... +2026-04-29 09:11:56,516 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:56,925 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 15 hr time horizon... +2026-04-29 09:11:56,957 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 10 hr time horizon... +2026-04-29 09:11:56,983 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 10 hr time horizon... +2026-04-29 09:11:57,006 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:57,521 - __main__ - INFO - Finished processing 2018-01-17 09:00:00 9 hr time horizon... +2026-04-29 09:11:57,544 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:59,683 - __main__ - INFO - Finished processing 2018-01-13 22:00:00 11 hr time horizon... +2026-04-29 09:11:59,703 - __main__ - INFO - Processing values: 2018-01-21 10:00:00 5 hr time horizon... +2026-04-29 09:11:59,870 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:11:59,893 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:02,149 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 1 hr time horizon... +2026-04-29 09:12:02,169 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:02,967 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 10 hr time horizon... +2026-04-29 09:12:02,987 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:03,228 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 16 hr time horizon... +2026-04-29 09:12:03,256 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:04,200 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 2 hr time horizon... +2026-04-29 09:12:04,224 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:04,860 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:04,884 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:05,439 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 6 hr time horizon... +2026-04-29 09:12:05,469 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:05,498 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 2 hr time horizon... +2026-04-29 09:12:05,518 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:05,869 - __main__ - INFO - Finished processing 2018-01-17 12:00:00 17 hr time horizon... +2026-04-29 09:12:05,891 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:06,864 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 11 hr time horizon... +2026-04-29 09:12:06,868 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 14 hr time horizon... +2026-04-29 09:12:06,892 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 15 hr time horizon... +2026-04-29 09:12:06,894 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:08,255 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 17 hr time horizon... +2026-04-29 09:12:08,278 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:09,002 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 10 hr time horizon... +2026-04-29 09:12:09,034 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:09,476 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 17 hr time horizon... +2026-04-29 09:12:09,501 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:11,820 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:11,845 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 8 hr time horizon... +2026-04-29 09:12:11,933 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:11,954 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 12 hr time horizon... +2026-04-29 09:12:11,973 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 16 hr time horizon... +2026-04-29 09:12:11,994 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:12,481 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 10 hr time horizon... +2026-04-29 09:12:12,503 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:14,720 - __main__ - INFO - Finished processing 2018-01-21 10:00:00 5 hr time horizon... +2026-04-29 09:12:14,739 - __main__ - INFO - Processing values: 2018-01-25 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:15,542 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 6 hr time horizon... +2026-04-29 09:12:15,569 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:16,588 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 16 hr time horizon... +2026-04-29 09:12:16,610 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:17,949 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 14 hr time horizon... +2026-04-29 09:12:17,978 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:18,080 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 13 hr time horizon... +2026-04-29 09:12:18,102 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:18,235 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:18,267 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:19,399 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:19,420 - __main__ - INFO - Processing values: 2018-01-08 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:19,912 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 10 hr time horizon... +2026-04-29 09:12:19,934 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:20,599 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 4 hr time horizon... +2026-04-29 09:12:20,621 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:20,752 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 15 hr time horizon... +2026-04-29 09:12:20,771 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:21,771 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:21,794 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:22,289 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:22,310 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:22,711 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 1 hr time horizon... +2026-04-29 09:12:22,727 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:23,483 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 12 hr time horizon... +2026-04-29 09:12:23,510 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:23,668 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 15 hr time horizon... +2026-04-29 09:12:23,689 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:24,860 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 11 hr time horizon... +2026-04-29 09:12:24,880 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:25,454 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:25,475 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 12 hr time horizon... +2026-04-29 09:12:25,975 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 12 hr time horizon... +2026-04-29 09:12:25,995 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 2 hr time horizon... +2026-04-29 09:12:26,016 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 8 hr time horizon... +2026-04-29 09:12:26,038 - __main__ - INFO - Processing values: 2018-01-16 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:28,732 - __main__ - INFO - Finished processing 2018-01-25 22:00:00 15 hr time horizon... +2026-04-29 09:12:28,755 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:30,000 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 10 hr time horizon... +2026-04-29 09:12:30,017 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:31,539 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 17 hr time horizon... +2026-04-29 09:12:31,558 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:32,369 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 13 hr time horizon... +2026-04-29 09:12:32,388 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:35,595 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 11 hr time horizon... +2026-04-29 09:12:35,620 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:36,078 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 7 hr time horizon... +2026-04-29 09:12:36,110 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:37,947 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 2 hr time horizon... +2026-04-29 09:12:37,975 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:39,892 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:39,919 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 7 hr time horizon... +2026-04-29 09:12:39,942 - __main__ - INFO - Finished processing 2018-01-08 21:00:00 2 hr time horizon... +2026-04-29 09:12:39,964 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:41,570 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 13 hr time horizon... +2026-04-29 09:12:41,590 - __main__ - INFO - Processing values: 2018-01-10 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:41,948 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 17 hr time horizon... +2026-04-29 09:12:41,969 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:43,259 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 13 hr time horizon... +2026-04-29 09:12:43,277 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:43,708 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 2 hr time horizon... +2026-04-29 09:12:43,729 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:44,172 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 12 hr time horizon... +2026-04-29 09:12:44,194 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:44,421 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 18 hr time horizon... +2026-04-29 09:12:44,442 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 16 hr time horizon... +2026-04-29 09:12:44,549 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 3 hr time horizon... +2026-04-29 09:12:44,570 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:45,272 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 17 hr time horizon... +2026-04-29 09:12:45,294 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:46,819 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:46,847 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:47,444 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 2 hr time horizon... +2026-04-29 09:12:47,464 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:48,669 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 15 hr time horizon... +2026-04-29 09:12:48,692 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:50,270 - __main__ - INFO - Finished processing 2018-01-16 11:00:00 18 hr time horizon... +2026-04-29 09:12:50,288 - __main__ - INFO - Processing values: 2018-01-21 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:50,549 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 4 hr time horizon... +2026-04-29 09:12:50,567 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:51,130 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 6 hr time horizon... +2026-04-29 09:12:51,145 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:53,400 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 15 hr time horizon... +2026-04-29 09:12:53,421 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:53,468 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 2 hr time horizon... +2026-04-29 09:12:53,488 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:54,614 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 7 hr time horizon... +2026-04-29 09:12:54,635 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:55,236 - __main__ - INFO - Finished processing 2018-01-10 23:00:00 13 hr time horizon... +2026-04-29 09:12:55,258 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:55,842 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 7 hr time horizon... +2026-04-29 09:12:55,859 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:56,778 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 17 hr time horizon... +2026-04-29 09:12:56,799 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:57,183 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 15 hr time horizon... +2026-04-29 09:12:57,203 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:58,609 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 16 hr time horizon... +2026-04-29 09:12:58,640 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:58,678 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:58,700 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:59,295 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 4 hr time horizon... +2026-04-29 09:12:59,314 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:12:59,827 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 7 hr time horizon... +2026-04-29 09:12:59,849 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:00,186 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 6 hr time horizon... +2026-04-29 09:13:00,208 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:00,737 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 18 hr time horizon... +2026-04-29 09:13:00,761 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:01,427 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:01,444 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:04,193 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 2 hr time horizon... +2026-04-29 09:13:04,218 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:05,036 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 18 hr time horizon... +2026-04-29 09:13:05,062 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:05,915 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 9 hr time horizon... +2026-04-29 09:13:05,937 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:07,912 - __main__ - INFO - Finished processing 2018-01-21 10:00:00 16 hr time horizon... +2026-04-29 09:13:07,936 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:09,259 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 6 hr time horizon... +2026-04-29 09:13:09,281 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:09,339 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 2 hr time horizon... +2026-04-29 09:13:09,362 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 7 hr time horizon... +2026-04-29 09:13:09,570 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 5 hr time horizon... +2026-04-29 09:13:09,596 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:09,773 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 5 hr time horizon... +2026-04-29 09:13:09,794 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 2 hr time horizon... +2026-04-29 09:13:09,814 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 12 hr time horizon... +2026-04-29 09:13:09,836 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:11,205 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 16 hr time horizon... +2026-04-29 09:13:11,226 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:12,570 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 9 hr time horizon... +2026-04-29 09:13:12,594 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:14,313 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 14 hr time horizon... +2026-04-29 09:13:14,344 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:14,708 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 15 hr time horizon... +2026-04-29 09:13:14,736 - __main__ - INFO - Processing values: 2018-01-02 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:14,970 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 9 hr time horizon... +2026-04-29 09:13:14,992 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:15,506 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:15,528 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 1 hr time horizon... +2026-04-29 09:13:15,620 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 18 hr time horizon... +2026-04-29 09:13:15,641 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:15,981 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 2 hr time horizon... +2026-04-29 09:13:16,001 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:16,200 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:16,223 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:17,488 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 8 hr time horizon... +2026-04-29 09:13:17,508 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:19,098 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 7 hr time horizon... +2026-04-29 09:13:19,122 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:19,987 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 13 hr time horizon... +2026-04-29 09:13:20,009 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:20,883 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 3 hr time horizon... +2026-04-29 09:13:20,903 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:13:22,002 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:22,023 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:23,198 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 2 hr time horizon... +2026-04-29 09:13:23,220 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:23,271 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 2 hr time horizon... +2026-04-29 09:13:23,291 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:23,412 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 11 hr time horizon... +2026-04-29 09:13:23,434 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:25,007 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 7 hr time horizon... +2026-04-29 09:13:25,028 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:25,286 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:25,310 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:25,927 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 15 hr time horizon... +2026-04-29 09:13:25,952 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:26,993 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:27,022 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:27,493 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 1 hr time horizon... +2026-04-29 09:13:27,515 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:28,895 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 12 hr time horizon... +2026-04-29 09:13:28,915 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:29,061 - __main__ - INFO - Finished processing 2018-01-02 00:00:00 14 hr time horizon... +2026-04-29 09:13:29,086 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:29,198 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 6 hr time horizon... +2026-04-29 09:13:29,218 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:29,374 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 4 hr time horizon... +2026-04-29 09:13:29,394 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:29,918 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 2 hr time horizon... +2026-04-29 09:13:29,939 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 4 hr time horizon... +2026-04-29 09:13:30,130 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 4 hr time horizon... +2026-04-29 09:13:30,147 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:33,020 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:33,057 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:34,238 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 1 hr time horizon... +2026-04-29 09:13:34,262 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:35,592 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 9 hr time horizon... +2026-04-29 09:13:35,619 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 8 hr time horizon... +2026-04-29 09:13:35,759 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 9 hr time horizon... +2026-04-29 09:13:35,784 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:38,042 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:38,062 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:38,547 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 16 hr time horizon... +2026-04-29 09:13:38,567 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:38,663 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 13 hr time horizon... +2026-04-29 09:13:38,685 - __main__ - INFO - Processing values: 2018-01-22 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:39,863 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 11 hr time horizon... +2026-04-29 09:13:39,890 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:39,934 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 6 hr time horizon... +2026-04-29 09:13:39,953 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 5 hr time horizon... +2026-04-29 09:13:40,028 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 11 hr time horizon... +2026-04-29 09:13:40,051 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:40,915 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 7 hr time horizon... +2026-04-29 09:13:40,937 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:41,555 - __main__ - INFO - Finished processing 2018-01-01 23:00:00 18 hr time horizon... +2026-04-29 09:13:41,580 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:44,060 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:44,084 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:44,592 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 18 hr time horizon... +2026-04-29 09:13:44,619 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:44,735 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 14 hr time horizon... +2026-04-29 09:13:44,761 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:45,446 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 18 hr time horizon... +2026-04-29 09:13:45,467 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:46,033 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 16 hr time horizon... +2026-04-29 09:13:46,057 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:46,374 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 11 hr time horizon... +2026-04-29 09:13:46,395 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:46,974 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 4 hr time horizon... +2026-04-29 09:13:46,998 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:49,165 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 3 hr time horizon... +2026-04-29 09:13:49,190 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:50,034 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 7 hr time horizon... +2026-04-29 09:13:50,051 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:50,898 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:50,920 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:51,451 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 2 hr time horizon... +2026-04-29 09:13:51,469 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:51,604 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 8 hr time horizon... +2026-04-29 09:13:51,626 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:53,744 - __main__ - INFO - Finished processing 2018-01-22 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:53,769 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:53,856 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 10 hr time horizon... +2026-04-29 09:13:53,878 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:55,367 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 5 hr time horizon... +2026-04-29 09:13:55,389 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:55,526 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 7 hr time horizon... +2026-04-29 09:13:55,549 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:55,681 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 3 hr time horizon... +2026-04-29 09:13:55,707 - __main__ - INFO - Processing values: 2018-01-13 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:57,420 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 18 hr time horizon... +2026-04-29 09:13:57,441 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:57,530 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 11 hr time horizon... +2026-04-29 09:13:57,551 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:58,355 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 15 hr time horizon... +2026-04-29 09:13:58,377 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:58,876 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 3 hr time horizon... +2026-04-29 09:13:58,899 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:59,313 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 8 hr time horizon... +2026-04-29 09:13:59,332 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:13:59,727 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 2 hr time horizon... +2026-04-29 09:13:59,746 - __main__ - INFO - Processing values: 2018-01-02 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:00,937 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:00,958 - __main__ - INFO - Processing values: 2018-01-04 01:00:00 9 hr time horizon... +2026-04-29 09:14:01,044 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 3 hr time horizon... +2026-04-29 09:14:01,063 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:01,509 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 7 hr time horizon... +2026-04-29 09:14:01,531 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 16 hr time horizon... +2026-04-29 09:14:01,975 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 17 hr time horizon... +2026-04-29 09:14:01,998 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:08,648 - __main__ - INFO - Finished processing 2018-01-13 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:08,667 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:09,964 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 1 hr time horizon... +2026-04-29 09:14:09,989 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:10,738 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 5 hr time horizon... +2026-04-29 09:14:10,759 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:11,424 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 7 hr time horizon... +2026-04-29 09:14:11,450 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:11,649 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 10 hr time horizon... +2026-04-29 09:14:11,672 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:12,609 - __main__ - INFO - Finished processing 2018-01-02 20:00:00 10 hr time horizon... +2026-04-29 09:14:12,632 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:13,821 - __main__ - INFO - Finished processing 2018-01-04 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:13,839 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:14,698 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 12 hr time horizon... +2026-04-29 09:14:14,721 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 15 hr time horizon... +2026-04-29 09:14:14,789 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:14,807 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 18 hr time horizon... +2026-04-29 09:14:14,912 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 18 hr time horizon... +2026-04-29 09:14:14,935 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() From 885469e21ac82812f588bf60d0a5117815192d23 Mon Sep 17 00:00:00 2001 From: kperry Date: Wed, 29 Apr 2026 09:15:43 -0600 Subject: [PATCH 14/17] update --- data/slurm_outputs/herbie_13573894.err | 3022 ++++++++++++++++++++++++ 1 file changed, 3022 insertions(+) diff --git a/data/slurm_outputs/herbie_13573894.err b/data/slurm_outputs/herbie_13573894.err index 123bee3a..e6c86a8d 100644 --- a/data/slurm_outputs/herbie_13573894.err +++ b/data/slurm_outputs/herbie_13573894.err @@ -32440,3 +32440,3025 @@ dsi = ds.herbie.nearest_points(points=points, /kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:15,946 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 10 hr time horizon... +2026-04-29 09:14:15,966 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 17 hr time horizon... +2026-04-29 09:14:16,221 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 3 hr time horizon... +2026-04-29 09:14:16,240 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:19,979 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 8 hr time horizon... +2026-04-29 09:14:19,996 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:24,193 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 1 hr time horizon... +2026-04-29 09:14:24,210 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:24,653 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:24,676 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 3 hr time horizon... +2026-04-29 09:14:24,727 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 11 hr time horizon... +2026-04-29 09:14:24,746 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 16 hr time horizon... +2026-04-29 09:14:24,759 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:24,778 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 6 hr time horizon... +2026-04-29 09:14:24,820 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 3 hr time horizon... +2026-04-29 09:14:24,840 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 5 hr time horizon... +2026-04-29 09:14:24,867 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 9 hr time horizon... +2026-04-29 09:14:24,885 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:26,031 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 3 hr time horizon... +2026-04-29 09:14:26,051 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:26,182 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 15 hr time horizon... +2026-04-29 09:14:26,204 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:28,232 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:28,257 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:28,485 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 15 hr time horizon... +2026-04-29 09:14:28,512 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:29,104 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 10 hr time horizon... +2026-04-29 09:14:29,127 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:29,354 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 17 hr time horizon... +2026-04-29 09:14:29,375 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 15 hr time horizon... +2026-04-29 09:14:29,454 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 4 hr time horizon... +2026-04-29 09:14:29,472 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:30,230 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 17 hr time horizon... +2026-04-29 09:14:30,253 - __main__ - INFO - Processing values: 2018-01-13 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:33,226 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 14 hr time horizon... +2026-04-29 09:14:33,245 - __main__ - INFO - Processing values: 2018-01-07 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:33,394 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 12 hr time horizon... +2026-04-29 09:14:33,417 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:34,177 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 12 hr time horizon... +2026-04-29 09:14:34,202 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:38,327 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:38,356 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:38,574 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 6 hr time horizon... +2026-04-29 09:14:38,583 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 13 hr time horizon... +2026-04-29 09:14:38,598 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 17 hr time horizon... +2026-04-29 09:14:38,605 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:38,691 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:38,714 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 16 hr time horizon... +2026-04-29 09:14:38,824 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 5 hr time horizon... +2026-04-29 09:14:38,847 - __main__ - INFO - Processing values: 2018-01-21 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:39,667 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 8 hr time horizon... +2026-04-29 09:14:39,677 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 18 hr time horizon... +2026-04-29 09:14:39,691 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 16 hr time horizon... +2026-04-29 09:14:39,702 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:40,165 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 18 hr time horizon... +2026-04-29 09:14:40,192 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:42,488 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:42,513 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:43,302 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 17 hr time horizon... +2026-04-29 09:14:43,323 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:43,562 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 10 hr time horizon... +2026-04-29 09:14:43,588 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:43,597 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 9 hr time horizon... +2026-04-29 09:14:43,618 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 18 hr time horizon... +2026-04-29 09:14:43,714 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 15 hr time horizon... +2026-04-29 09:14:43,733 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:44,165 - __main__ - INFO - Finished processing 2018-01-13 09:00:00 17 hr time horizon... +2026-04-29 09:14:44,181 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 1 hr time horizon... +2026-04-29 09:14:44,536 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 5 hr time horizon... +2026-04-29 09:14:44,557 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:48,581 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 18 hr time horizon... +2026-04-29 09:14:48,603 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 1 hr time horizon... +2026-04-29 09:14:48,743 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 4 hr time horizon... +2026-04-29 09:14:48,766 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:48,919 - __main__ - INFO - Finished processing 2018-01-07 15:00:00 7 hr time horizon... +2026-04-29 09:14:48,947 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:50,569 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 10 hr time horizon... +2026-04-29 09:14:50,592 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:53,328 - __main__ - INFO - Finished processing 2018-01-21 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:53,358 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:54,049 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 18 hr time horizon... +2026-04-29 09:14:54,066 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:54,127 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 13 hr time horizon... +2026-04-29 09:14:54,150 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:54,887 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 16 hr time horizon... +2026-04-29 09:14:54,909 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:55,432 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 10 hr time horizon... +2026-04-29 09:14:55,452 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:55,950 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 18 hr time horizon... +2026-04-29 09:14:55,972 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:56,118 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 16 hr time horizon... +2026-04-29 09:14:56,139 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:57,575 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 14 hr time horizon... +2026-04-29 09:14:57,596 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:58,719 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 17 hr time horizon... +2026-04-29 09:14:58,744 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:58,853 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 16 hr time horizon... +2026-04-29 09:14:58,875 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:58,990 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 13 hr time horizon... +2026-04-29 09:14:59,013 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:59,453 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 5 hr time horizon... +2026-04-29 09:14:59,457 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 18 hr time horizon... +2026-04-29 09:14:59,479 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 9 hr time horizon... +2026-04-29 09:14:59,484 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:14:59,668 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 1 hr time horizon... +2026-04-29 09:14:59,687 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:00,198 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 12 hr time horizon... +2026-04-29 09:15:00,219 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:03,043 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 2 hr time horizon... +2026-04-29 09:15:03,063 - __main__ - INFO - Processing values: 2018-01-03 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:03,305 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 1 hr time horizon... +2026-04-29 09:15:03,324 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:03,810 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 2 hr time horizon... +2026-04-29 09:15:03,841 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:04,910 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 17 hr time horizon... +2026-04-29 09:15:04,935 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:07,484 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 3 hr time horizon... +2026-04-29 09:15:07,501 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:08,447 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 2 hr time horizon... +2026-04-29 09:15:08,468 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:10,214 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 6 hr time horizon... +2026-04-29 09:15:10,244 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:10,413 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 15 hr time horizon... +2026-04-29 09:15:10,442 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:10,965 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 8 hr time horizon... +2026-04-29 09:15:10,992 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:11,037 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 14 hr time horizon... +2026-04-29 09:15:11,062 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:11,473 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 5 hr time horizon... +2026-04-29 09:15:11,509 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:12,369 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 16 hr time horizon... +2026-04-29 09:15:12,399 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:14,158 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:14,190 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:14,616 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 10 hr time horizon... +2026-04-29 09:15:14,637 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 4 hr time horizon... +2026-04-29 09:15:14,693 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 17 hr time horizon... +2026-04-29 09:15:14,715 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 14 hr time horizon... +2026-04-29 09:15:14,836 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 16 hr time horizon... +2026-04-29 09:15:14,875 - __main__ - INFO - Processing values: 2018-01-14 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:14,981 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 9 hr time horizon... +2026-04-29 09:15:15,001 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 8 hr time horizon... +2026-04-29 09:15:15,224 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 12 hr time horizon... +2026-04-29 09:15:15,246 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:15,866 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 13 hr time horizon... +2026-04-29 09:15:15,887 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:19,159 - __main__ - INFO - Finished processing 2018-01-03 06:00:00 17 hr time horizon... +2026-04-29 09:15:19,180 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 15 hr time horizon... +2026-04-29 09:15:19,226 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:19,253 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:20,093 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 4 hr time horizon... +2026-04-29 09:15:20,114 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:21,673 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 5 hr time horizon... +2026-04-29 09:15:21,697 - __main__ - INFO - Processing values: 2018-01-02 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:24,940 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:24,958 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:25,203 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 15 hr time horizon... +2026-04-29 09:15:25,231 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:25,653 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 7 hr time horizon... +2026-04-29 09:15:25,676 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:26,644 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 13 hr time horizon... +2026-04-29 09:15:26,678 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:27,537 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 18 hr time horizon... +2026-04-29 09:15:27,564 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:27,982 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:28,006 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:28,496 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:28,522 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:29,279 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:29,299 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 5 hr time horizon... +2026-04-29 09:15:29,338 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:29,359 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:29,752 - __main__ - INFO - Finished processing 2018-01-14 09:00:00 13 hr time horizon... +2026-04-29 09:15:29,769 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 17 hr time horizon... +2026-04-29 09:15:29,792 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 7 hr time horizon... +2026-04-29 09:15:29,809 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 4 hr time horizon... +2026-04-29 09:15:29,957 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:29,980 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:30,915 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 1 hr time horizon... +2026-04-29 09:15:30,936 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:31,180 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 13 hr time horizon... +2026-04-29 09:15:31,202 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:33,039 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 18 hr time horizon... +2026-04-29 09:15:33,059 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:33,795 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 14 hr time horizon... +2026-04-29 09:15:33,817 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:35,058 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 15 hr time horizon... +2026-04-29 09:15:35,081 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:36,104 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 10 hr time horizon... +2026-04-29 09:15:36,125 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:37,590 - __main__ - INFO - Finished processing 2018-01-02 12:00:00 11 hr time horizon... +2026-04-29 09:15:37,612 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:41,464 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 6 hr time horizon... +2026-04-29 09:15:41,487 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:42,762 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 5 hr time horizon... +2026-04-29 09:15:42,784 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 6 hr time horizon... From 979410fbebf5b2f8cb538b67d01dc405591bb296 Mon Sep 17 00:00:00 2001 From: kperry Date: Wed, 29 Apr 2026 09:19:01 -0600 Subject: [PATCH 15/17] removed random files --- data/merge_conus_nsrdb.py | 107 - data/run_pvdrdb_sites_pvwatts.py | 155 - data/slurm_outputs/herbie_13573894.err | 5860 ++++++++++++++++++++++++ 3 files changed, 5860 insertions(+), 262 deletions(-) delete mode 100644 data/merge_conus_nsrdb.py delete mode 100644 data/run_pvdrdb_sites_pvwatts.py diff --git a/data/merge_conus_nsrdb.py b/data/merge_conus_nsrdb.py deleted file mode 100644 index 345dff77..00000000 --- a/data/merge_conus_nsrdb.py +++ /dev/null @@ -1,107 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Pull NSRDB and CONUS data at different nodes for comparison. -""" - -import pandas as pd -from utils import geohash, nsrdb_weather, nsrdb_credentials -import requests -import io -import pvdrdb_tools -import time - -pdv = pvdrdb_tools.PVDRDBQuery() - -def pull_CONUS_data(latitude, longitude, hub_height, - year): - available_hub_heights = [10] +[*range(20,200, 20)] - # Get the closest hub height to the existing turbine - closest_hub_height = int(min(available_hub_heights, - key=lambda x:abs(x-hub_height))) - payload_attributes = ("temperature_" + str(int(closest_hub_height))+ - "m,pressure_0m,windspeed_" + - str(int(closest_hub_height))+ "m,winddirection_" + - str(int(closest_hub_height))+ "m") - email, api_key = nsrdb_credentials() - url = ( - "http://developer.nrel.gov/api/wind-toolkit/v2/"+ - "wind/wtk-bchrrr-v1-0-0-download.csv?wkt=POINT(" - + str(longitude) + " " + str(latitude) + - ")&attributes=" + payload_attributes + - "&names=" +str(year) + - "&utc=true&leap_day=true&email=" + str(email) + "&api_key=" + - str(api_key)) - x = requests.get(url) - # Process the data into CSV format - weather_data = pd.read_csv(io.StringIO(x.content.decode('utf-8'))) - weather_data.drop(columns=weather_data.columns[-1], inplace=True) - timezone = int(weather_data.columns[3]) - weather_data.columns = ['Year', 'Month', 'Day', 'Hour', - 'Minute', 'Air Temperature at hub height (°C)', - 'Surface Air Pressure (Pa)', - 'Wind Speed at hub height (m/s)', - 'Wind Direction at hub height(°)'] - weather_data['hub_height'] = hub_height - index_cutoff = weather_data[weather_data['Year'] =='Year'].index[0] - weather_data = weather_data[weather_data.index > index_cutoff] - weather_data.index = pd.to_datetime(weather_data['Year'] + "-" + - weather_data['Month'] + "-" + - weather_data['Day'] + " " + - weather_data['Hour'] + - ":" + weather_data['Minute'] + ":00") - weather_data.index = weather_data.index.tz_localize('UTC') - weather_data = weather_data[['Air Temperature at hub height (°C)', - 'Surface Air Pressure (Pa)', - 'Wind Speed at hub height (m/s)', - 'Wind Direction at hub height(°)']] - return weather_data - - -if __name__ == "__main__": - # Point towards the particular local folder that contains the data - metadata = pd.read_csv("nodes.csv") - # Loop through the metadata and generate the associated estimates - #metadata = metadata[metadata.index>=78] - for idx, row in metadata.iterrows(): - lat = row['Lat'] - long = row['Long'] - geohash_val = geohash(lat, long, precision=6) - min_measured_date = pd.to_datetime("2018-01-01") - max_measured_date = pd.to_datetime("2022-12-31") - # Pull the site's associated NSRDB data - master_weather_df = pd.DataFrame() - for year in range(min_measured_date.year, max_measured_date.year): - for try_time in range(0,3): - try: - df = nsrdb_weather(geohash_val, - year, - interval=30, - attributes={'Temperature': 'temp_air', - 'DHI': 'dhi', - 'DNI': 'dni', - 'GHI': 'ghi', - 'Wind Speed': 'wind_speed'}) - master_weather_df = pd.concat([master_weather_df, df]) - except: - pass - # Pull the CONUS data for the same associated period for direct comparison - master_conus_df = pd.DataFrame() - for year in range(min_measured_date.year, max_measured_date.year): - tries = 0 - while tries < 3: - try: - conus_df = pull_CONUS_data(lat, long, 80, year) - master_conus_df = pd.concat([master_conus_df, conus_df]) - time.sleep(1) - break - except: - tries += 1 - time.sleep(1) - # Merge the data sets together - df_merge = pd.merge(master_weather_df, master_conus_df, - left_index=True, right_index=True) - # Write to S3 - df_merge.to_csv('s3://pvdrdb-transfer/REGROW/nsrdb_conus_data/' - + str(row['geocode']) + '.csv', - storage_options={"key": pdv.aws['key'], - "secret": pdv.aws['secret']}) \ No newline at end of file diff --git a/data/run_pvdrdb_sites_pvwatts.py b/data/run_pvdrdb_sites_pvwatts.py deleted file mode 100644 index 429a64ce..00000000 --- a/data/run_pvdrdb_sites_pvwatts.py +++ /dev/null @@ -1,155 +0,0 @@ -from pvlib.modelchain import ModelChain -from pvlib.pvsystem import PVSystem -from pvlib.location import Location -import pandas as pd -import math -import requests -import json -import os -import pvlib -from pvlib.temperature import TEMPERATURE_MODEL_PARAMETERS -from matplotlib import pyplot as plt -from utils import geohash, nsrdb_weather -import glob -import pvdrdb_tools - -pdv = pvdrdb_tools.PVDRDBQuery() - -def run_pvwatts_model(tilt, azimuth, dc_capacity, dc_inverter_limit, - solar_zenith, solar_azimuth, dni, dhi, ghi, dni_extra, - relative_airmass, temperature, wind_speed, - temperature_model_parameters, - temperature_coefficient, tracking): - """ - Run the PVWatts model using NSRDB data across the time period as inputs. - """ - if tracking: - tracker_angles = pvlib.tracking.singleaxis(solar_zenith, solar_azimuth, - axis_tilt=tilt, axis_azimuth=azimuth, - backtrack=True, gcr=0.4, max_angle=60) - surface_tilt = tracker_angles['surface_tilt'] - surface_azimuth = tracker_angles['surface_azimuth'] - else: - surface_tilt = tilt - surface_azimuth = azimuth - - poa = pvlib.irradiance.get_total_irradiance( - surface_tilt, surface_azimuth, - solar_zenith, - solar_azimuth, - dni, ghi, dhi, - dni_extra=dni_extra, - airmass=relative_airmass, - albedo=0.2, - model='perez' - ) - - aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth, - solar_zenith, solar_azimuth) - # Run IAM model - iam = pvlib.iam.physical(aoi, n=1.5) - # Apply IAM to direct POA component only - poa_transmitted = poa['poa_direct'] * iam + poa['poa_diffuse'] - temp_cell = pvlib.temperature.sapm_cell( - poa['poa_global'], - temperature, - wind_speed, - **temperature_model_parameters - ) - pdc = pvlib.pvsystem.pvwatts_dc( - poa_transmitted, - temp_cell, - dc_capacity, - temperature_coefficient - ) - return pdc - - -if __name__ == "__main__": - # Point towards the particular local folder that contains the data - data_path = "C:/Users/kperry/Documents/extreme-weather-ca-heatwave/pvwatts_pvdrdb_systems" - time_series_path = "C:/Users/kperry/Documents/extreme-weather-ca-heatwave" - metadata = pd.read_csv(os.path.join(time_series_path, - "all_states_heatwave_target_sites.csv")) - already_run = glob.glob(data_path +"/*.csv") - already_run = [os.path.basename(x) for x in already_run] - # Loop through the metadata and generate the associated estimates - for idx, row in metadata.iterrows(): - lat = row['latitude'] - long = row['longitude'] - name = row['name'] - # Get the geohash associated with the site - system_identifier = str(row['system_id']) - if system_identifier + ".csv" in already_run: - print("already run!!") - continue - geohash_val = geohash(lat, long, precision=6) - # convert to KW - power = row['power'] - tilt = row['tilt'] - azimuth = row['azimuth'] - if row['tracking']: - tracking = False - else: - tracking = True - backtracking = False - # Default tilt 0 for single-axis tracking if missing, 20 for fixed-tilt - if str(tilt) == "nan": - if tracking: - tilt = 0 - else: - tilt = 20 - min_measured_date = pd.to_datetime(row['min_measured_date']) - max_measured_date = pd.to_datetime(row['max_measured_date']) - print(min_measured_date, max_measured_date) - # Pull the site's associated NSRDB data - master_weather_df = pd.DataFrame() - for year in range(min_measured_date.year, max_measured_date.year): - for try_time in range(0,3): - try: - df = nsrdb_weather(geohash_val, - year, - interval=30, - attributes={'Temperature': 'temp_air', - 'DHI': 'dhi', - 'DNI': 'dni', - 'GHI': 'ghi', - 'Wind Speed': 'wind_speed'}) - master_weather_df = pd.concat([master_weather_df, df]) - break - except: - pass - # Build out the PVWatts model - solpos = pvlib.solarposition.get_solarposition(master_weather_df.index, - lat, long) - dni_extra = pvlib.irradiance.get_extra_radiation(master_weather_df.index) - relative_airmass = pvlib.atmosphere.get_relative_airmass(solpos.zenith) - temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass'] - pdc = run_pvwatts_model(tilt=tilt, - azimuth=azimuth, - dc_capacity=power, - dc_inverter_limit=power * 1.5, - solar_zenith=solpos.zenith, - solar_azimuth=solpos.azimuth, - dni=master_weather_df['DNI'], - dhi=master_weather_df['DHI'], - ghi=master_weather_df['GHI'], - dni_extra=dni_extra, - relative_airmass=relative_airmass, - temperature=master_weather_df['Temperature'], - wind_speed=master_weather_df['Wind Speed'], - temperature_model_parameters=temp_params, - temperature_coefficient=-0.0047, - tracking=tracking) - # Plot PDC against real - pdc.plot() - # Plot real - plt.show() - plt.close() - pdc.name = "output_kW" - # Write the results to the associated S3 bucket. - pdc.to_csv('s3://pvdrdb-transfer/REGROW/pvwatts_pvdrdb_systems/' - + str(system_identifier) + '.csv', - storage_options={"key": pdv.aws['key'], - "secret": pdv.aws['secret']}) - \ No newline at end of file diff --git a/data/slurm_outputs/herbie_13573894.err b/data/slurm_outputs/herbie_13573894.err index e6c86a8d..4fcfd8cc 100644 --- a/data/slurm_outputs/herbie_13573894.err +++ b/data/slurm_outputs/herbie_13573894.err @@ -35462,3 +35462,5863 @@ ds = ds.metpy.assign_y_x() 2026-04-29 09:15:42,762 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 5 hr time horizon... 2026-04-29 09:15:42,784 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,015 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 2 hr time horizon... +2026-04-29 09:15:44,036 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,374 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:15:44,392 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,612 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,634 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,886 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:44,905 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:47,064 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 17 hr time horizon... +2026-04-29 09:15:47,097 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:47,253 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:47,285 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:47,767 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 5 hr time horizon... +2026-04-29 09:15:47,786 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:47,985 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 4 hr time horizon... +2026-04-29 09:15:48,019 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:48,114 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 10 hr time horizon... +2026-04-29 09:15:48,135 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 18 hr time horizon... +2026-04-29 09:15:48,138 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:48,163 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:48,596 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 4 hr time horizon... +2026-04-29 09:15:48,616 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:49,233 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 7 hr time horizon... +2026-04-29 09:15:49,264 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:49,866 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 13 hr time horizon... +2026-04-29 09:15:49,886 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 6 hr time horizon... +2026-04-29 09:15:49,976 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:50,002 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:50,317 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:50,350 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:50,982 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 5 hr time horizon... +2026-04-29 09:15:51,002 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:51,514 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 2 hr time horizon... +2026-04-29 09:15:51,532 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:53,178 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 7 hr time horizon... +2026-04-29 09:15:53,202 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:55,426 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 10 hr time horizon... +2026-04-29 09:15:55,445 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:58,320 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 9 hr time horizon... +2026-04-29 09:15:58,339 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:15:58,919 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 9 hr time horizon... +2026-04-29 09:15:58,939 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:01,469 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 10 hr time horizon... +2026-04-29 09:16:01,491 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:16:01,515 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:01,541 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:01,936 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 18 hr time horizon... +2026-04-29 09:16:01,956 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:02,565 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 18 hr time horizon... +2026-04-29 09:16:02,588 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:02,653 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 7 hr time horizon... +2026-04-29 09:16:02,677 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:02,788 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 9 hr time horizon... +2026-04-29 09:16:02,808 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:02,854 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 18 hr time horizon... +2026-04-29 09:16:02,875 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 7 hr time horizon... +2026-04-29 09:16:02,910 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 16 hr time horizon... +2026-04-29 09:16:02,930 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:03,038 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 9 hr time horizon... +2026-04-29 09:16:03,064 - __main__ - INFO - Processing values: 2018-01-26 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:04,141 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:04,164 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:05,011 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 2 hr time horizon... +2026-04-29 09:16:05,030 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 18 hr time horizon... +2026-04-29 09:16:05,110 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 18 hr time horizon... +2026-04-29 09:16:05,135 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:05,984 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 6 hr time horizon... +2026-04-29 09:16:06,009 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:06,150 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 9 hr time horizon... +2026-04-29 09:16:06,175 - __main__ - INFO - Processing values: 2018-01-28 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:08,181 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 3 hr time horizon... +2026-04-29 09:16:08,205 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 1 hr time horizon... +2026-04-29 09:16:08,260 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 10 hr time horizon... +2026-04-29 09:16:08,283 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:08,724 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 3 hr time horizon... +2026-04-29 09:16:08,748 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:11,381 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 13 hr time horizon... +2026-04-29 09:16:11,406 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:12,647 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 2 hr time horizon... +2026-04-29 09:16:12,668 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:13,777 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 14 hr time horizon... +2026-04-29 09:16:13,800 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:16,484 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 2 hr time horizon... +2026-04-29 09:16:16,502 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:17,044 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 11 hr time horizon... +2026-04-29 09:16:17,068 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:17,297 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 10 hr time horizon... +2026-04-29 09:16:17,328 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:17,526 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 17 hr time horizon... +2026-04-29 09:16:17,547 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:17,829 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 7 hr time horizon... +2026-04-29 09:16:17,850 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:18,721 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 16 hr time horizon... +2026-04-29 09:16:18,743 - __main__ - INFO - Processing values: 2018-01-02 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:18,767 - __main__ - INFO - Finished processing 2018-01-26 16:00:00 17 hr time horizon... +2026-04-29 09:16:18,792 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:19,714 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 10 hr time horizon... +2026-04-29 09:16:19,745 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:19,787 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 3 hr time horizon... +2026-04-29 09:16:19,812 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:20,856 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 15 hr time horizon... +2026-04-29 09:16:20,878 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:21,304 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 14 hr time horizon... +2026-04-29 09:16:21,327 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:21,462 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 18 hr time horizon... +2026-04-29 09:16:21,488 - __main__ - INFO - Processing values: 2018-01-04 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:22,454 - __main__ - INFO - Finished processing 2018-01-28 02:00:00 12 hr time horizon... +2026-04-29 09:16:22,477 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:23,079 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:23,101 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 8 hr time horizon... +2026-04-29 09:16:23,262 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:23,286 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:24,440 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 3 hr time horizon... +2026-04-29 09:16:24,459 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 5 hr time horizon... +2026-04-29 09:16:24,534 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 4 hr time horizon... +2026-04-29 09:16:24,556 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:27,941 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 11 hr time horizon... +2026-04-29 09:16:27,964 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:29,208 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 18 hr time horizon... +2026-04-29 09:16:29,242 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:30,834 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:30,857 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:31,962 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:31,986 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:32,992 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:33,014 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:33,704 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 13 hr time horizon... +2026-04-29 09:16:33,727 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,063 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 13 hr time horizon... +2026-04-29 09:16:34,090 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,133 - __main__ - INFO - Finished processing 2018-01-02 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,156 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,400 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 11 hr time horizon... +2026-04-29 09:16:34,421 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,615 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:34,641 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:35,521 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 7 hr time horizon... +2026-04-29 09:16:35,541 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:36,952 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 12 hr time horizon... +2026-04-29 09:16:36,978 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:37,044 - __main__ - INFO - Finished processing 2018-01-04 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:37,073 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:37,114 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 6 hr time horizon... +2026-04-29 09:16:37,136 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:37,744 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 18 hr time horizon... +2026-04-29 09:16:37,765 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:39,025 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 12 hr time horizon... +2026-04-29 09:16:39,047 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 8 hr time horizon... +2026-04-29 09:16:39,221 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 18 hr time horizon... +2026-04-29 09:16:39,250 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:39,997 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 5 hr time horizon... +2026-04-29 09:16:40,018 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:41,954 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 7 hr time horizon... +2026-04-29 09:16:41,979 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:42,879 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 8 hr time horizon... +2026-04-29 09:16:42,908 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:44,264 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 17 hr time horizon... +2026-04-29 09:16:44,286 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:44,954 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:44,980 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:48,039 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:48,074 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:48,165 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 2 hr time horizon... +2026-04-29 09:16:48,174 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 1 hr time horizon... +2026-04-29 09:16:48,189 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 2 hr time horizon... +2026-04-29 09:16:48,194 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:49,511 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 4 hr time horizon... +2026-04-29 09:16:49,531 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:49,934 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 10 hr time horizon... +2026-04-29 09:16:49,955 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 4 hr time horizon... +2026-04-29 09:16:49,973 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 15 hr time horizon... +2026-04-29 09:16:50,003 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:50,909 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 5 hr time horizon... +2026-04-29 09:16:50,935 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:51,932 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:51,957 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:52,742 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:52,770 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:52,991 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 7 hr time horizon... +2026-04-29 09:16:53,021 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:53,140 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 15 hr time horizon... +2026-04-29 09:16:53,163 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:54,068 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 18 hr time horizon... +2026-04-29 09:16:54,091 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 17 hr time horizon... +2026-04-29 09:16:54,118 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 15 hr time horizon... +2026-04-29 09:16:54,139 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:55,400 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 8 hr time horizon... +2026-04-29 09:16:55,426 - __main__ - INFO - Processing values: 2018-01-03 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:55,744 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 15 hr time horizon... +2026-04-29 09:16:55,766 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:57,860 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 1 hr time horizon... +2026-04-29 09:16:57,882 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:58,308 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 5 hr time horizon... +2026-04-29 09:16:58,328 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:59,187 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:16:59,208 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:00,758 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 11 hr time horizon... +2026-04-29 09:17:00,780 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:01,298 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 6 hr time horizon... +2026-04-29 09:17:01,328 - __main__ - INFO - Processing values: 2018-01-27 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:04,320 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 8 hr time horizon... +2026-04-29 09:17:04,345 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:04,597 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 2 hr time horizon... +2026-04-29 09:17:04,617 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:04,628 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 13 hr time horizon... +2026-04-29 09:17:04,663 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:05,522 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 12 hr time horizon... +2026-04-29 09:17:05,544 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:05,855 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:05,881 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:06,089 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 12 hr time horizon... +2026-04-29 09:17:06,114 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:06,493 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 17 hr time horizon... +2026-04-29 09:17:06,514 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:07,898 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 6 hr time horizon... +2026-04-29 09:17:07,920 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:08,529 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 8 hr time horizon... +2026-04-29 09:17:08,559 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:08,656 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 13 hr time horizon... +2026-04-29 09:17:08,679 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:09,723 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:09,747 - __main__ - INFO - Processing values: 2018-01-16 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:09,872 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 7 hr time horizon... +2026-04-29 09:17:09,891 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:10,354 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 12 hr time horizon... +2026-04-29 09:17:10,378 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:11,761 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 7 hr time horizon... +2026-04-29 09:17:11,783 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:12,841 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 5 hr time horizon... +2026-04-29 09:17:12,860 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:13,832 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:13,854 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:14,250 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 15 hr time horizon... +2026-04-29 09:17:14,272 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:14,824 - __main__ - INFO - Finished processing 2018-01-03 17:00:00 17 hr time horizon... +2026-04-29 09:17:14,844 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:16,186 - __main__ - INFO - Finished processing 2018-01-27 20:00:00 6 hr time horizon... +2026-04-29 09:17:16,211 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:19,053 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 6 hr time horizon... +2026-04-29 09:17:19,073 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:19,152 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 9 hr time horizon... +2026-04-29 09:17:19,174 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:19,890 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 3 hr time horizon... +2026-04-29 09:17:19,911 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:20,609 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:20,633 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:21,175 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 13 hr time horizon... +2026-04-29 09:17:21,200 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 12 hr time horizon... +2026-04-29 09:17:21,247 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 6 hr time horizon... +2026-04-29 09:17:21,272 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:21,464 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 16 hr time horizon... +2026-04-29 09:17:21,488 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:23,002 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 4 hr time horizon... +2026-04-29 09:17:23,033 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:23,571 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 4 hr time horizon... +2026-04-29 09:17:23,597 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:24,794 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 9 hr time horizon... +2026-04-29 09:17:24,817 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:25,215 - __main__ - INFO - Finished processing 2018-01-16 11:00:00 17 hr time horizon... +2026-04-29 09:17:25,237 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:25,506 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 18 hr time horizon... +2026-04-29 09:17:25,527 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:25,768 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 13 hr time horizon... +2026-04-29 09:17:25,790 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 10 hr time horizon... +2026-04-29 09:17:25,806 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 15 hr time horizon... +2026-04-29 09:17:25,828 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:27,860 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 7 hr time horizon... +2026-04-29 09:17:27,885 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:29,740 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 9 hr time horizon... +2026-04-29 09:17:29,767 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 15 hr time horizon... +2026-04-29 09:17:29,925 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 6 hr time horizon... +2026-04-29 09:17:29,950 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:30,961 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 1 hr time horizon... +2026-04-29 09:17:30,981 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:33,312 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 14 hr time horizon... +2026-04-29 09:17:33,337 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:33,410 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 2 hr time horizon... +2026-04-29 09:17:33,437 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:35,264 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 17 hr time horizon... +2026-04-29 09:17:35,299 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:36,079 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:36,110 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:36,741 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 17 hr time horizon... +2026-04-29 09:17:36,764 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:36,861 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 13 hr time horizon... +2026-04-29 09:17:36,882 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 16 hr time horizon... +2026-04-29 09:17:36,901 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 13 hr time horizon... +2026-04-29 09:17:36,931 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:36,977 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 8 hr time horizon... +2026-04-29 09:17:36,998 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:37,250 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 12 hr time horizon... +2026-04-29 09:17:37,270 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:38,924 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 1 hr time horizon... +2026-04-29 09:17:38,946 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:39,028 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 11 hr time horizon... +2026-04-29 09:17:39,053 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:41,231 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 12 hr time horizon... +2026-04-29 09:17:41,254 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 15 hr time horizon... +2026-04-29 09:17:41,357 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 10 hr time horizon... +2026-04-29 09:17:41,382 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 5 hr time horizon... +2026-04-29 09:17:41,495 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 16 hr time horizon... +2026-04-29 09:17:41,520 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:41,730 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 14 hr time horizon... +2026-04-29 09:17:41,752 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:44,043 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 8 hr time horizon... +2026-04-29 09:17:44,066 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:46,012 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 10 hr time horizon... +2026-04-29 09:17:46,035 - __main__ - INFO - Processing values: 2018-01-18 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:46,994 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 17 hr time horizon... +2026-04-29 09:17:47,015 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:47,079 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:47,103 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:48,363 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 15 hr time horizon... +2026-04-29 09:17:48,388 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:49,252 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 7 hr time horizon... +2026-04-29 09:17:49,272 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:49,729 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 11 hr time horizon... +2026-04-29 09:17:49,751 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:50,897 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:50,925 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:51,841 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 9 hr time horizon... +2026-04-29 09:17:51,870 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:52,404 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 9 hr time horizon... +2026-04-29 09:17:52,425 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:53,029 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 16 hr time horizon... +2026-04-29 09:17:53,052 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:53,303 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:17:53,335 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:53,381 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 13 hr time horizon... +2026-04-29 09:17:53,406 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:53,568 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 8 hr time horizon... +2026-04-29 09:17:53,591 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:54,291 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 1 hr time horizon... +2026-04-29 09:17:54,313 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 14 hr time horizon... +2026-04-29 09:17:54,452 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 18 hr time horizon... +2026-04-29 09:17:54,474 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:57,389 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 5 hr time horizon... +2026-04-29 09:17:57,410 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:57,863 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 14 hr time horizon... +2026-04-29 09:17:57,885 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 15 hr time horizon... +2026-04-29 09:17:57,947 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 13 hr time horizon... +2026-04-29 09:17:57,971 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:59,622 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:17:59,645 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:00,756 - __main__ - INFO - Finished processing 2018-01-18 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:00,777 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:01,584 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:01,610 - __main__ - INFO - Processing values: 2018-01-28 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:02,370 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 7 hr time horizon... +2026-04-29 09:18:02,393 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:02,525 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 14 hr time horizon... +2026-04-29 09:18:02,553 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:03,340 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 6 hr time horizon... +2026-04-29 09:18:03,360 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:04,474 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 3 hr time horizon... +2026-04-29 09:18:04,493 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:05,202 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 7 hr time horizon... +2026-04-29 09:18:05,225 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:06,919 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 17 hr time horizon... +2026-04-29 09:18:06,943 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:19,522 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 6 hr time horizon... +2026-04-29 09:18:19,538 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:29,392 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 3 hr time horizon... +2026-04-29 09:18:29,408 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:32,133 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 11 hr time horizon... +2026-04-29 09:18:32,150 - __main__ - INFO - Processing values: 2018-01-29 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:34,390 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 13 hr time horizon... +2026-04-29 09:18:34,409 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:36,275 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 12 hr time horizon... +2026-04-29 09:18:36,292 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:46,010 - __main__ - INFO - Finished processing 2018-01-29 06:00:00 12 hr time horizon... +2026-04-29 09:18:46,030 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:47,136 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 17 hr time horizon... +2026-04-29 09:18:47,154 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:48,591 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 17 hr time horizon... +2026-04-29 09:18:48,609 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 18 hr time horizon... +2026-04-29 09:18:48,788 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 6 hr time horizon... +2026-04-29 09:18:48,805 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:18:59,358 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 11 hr time horizon... +2026-04-29 09:18:59,364 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 5 hr time horizon... +2026-04-29 09:18:59,369 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 5 hr time horizon... +2026-04-29 09:18:59,382 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 14 hr time horizon... +2026-04-29 09:18:59,392 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 7 hr time horizon... +2026-04-29 09:18:59,392 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 15 hr time horizon... +2026-04-29 09:18:59,865 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 13 hr time horizon... +2026-04-29 09:18:59,882 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() From cc5e573d0765bb800b7adc71bef6ff083a64988c Mon Sep 17 00:00:00 2001 From: kperry Date: Wed, 29 Apr 2026 09:19:50 -0600 Subject: [PATCH 16/17] removed random ercot file? --- data/ercot_mora_solar_sites.csv | 293 ------ data/slurm_outputs/herbie_13573894.err | 1338 ++++++++++++++++++++++++ 2 files changed, 1338 insertions(+), 293 deletions(-) delete mode 100644 data/ercot_mora_solar_sites.csv diff --git a/data/ercot_mora_solar_sites.csv b/data/ercot_mora_solar_sites.csv deleted file mode 100644 index 64a18eaa..00000000 --- a/data/ercot_mora_solar_sites.csv +++ /dev/null @@ -1,293 +0,0 @@ -UNIT NAME,UNIT CODE,COUNTY,INSTALLED CAPACITY RATING (MW) -7V SOLAR,7RNCHSLR_UNIT1,FAYETTE,139.5 -7V SOLAR U2,7RNCHSLR_UNIT2,FAYETTE,95.54 -7V SOLAR U3,7RNCHSLR_UNIT3,FAYETTE,5.57 -ACACIA SOLAR,ACACIA_UNIT_1,PRESIDIO,10.0 -ALEXIS SOLAR,ALEXIS_ALEXIS,BROOKS,10.0 -ANDROMEDA SOLAR U1,ANDMDSLR_UNIT1,SCURRY,158.8 -ANDROMEDA SOLAR U2,ANDMDSLR_UNIT2,SCURRY,162.4 -ANGELO SOLAR,ANG_SLR_UNIT1,TOM GREEN,195.41 -ANSON SOLAR U1,ANSON1_UNIT1,JONES,100.8 -ANSON SOLAR U2,ANSON1_UNIT2,JONES,100.8 -ARAGORN SOLAR,ARAGORN_UNIT1,CULBERSON,188.2 -AUREOLA SOLAR U1,AURO_SLR_UNIT1,MILAM,201.66 -AZURE SKY SOLAR U1,AZURE_SOLAR1,HASKELL,74.9 -AZURE SKY SOLAR U2,AZURE_SOLAR2,HASKELL,153.5 -BHE SOLAR PEARL PROJECT (SIRIUS 2),SIRIUS_UNIT2,PECOS,50.0 -BIG ELM SOLAR,BELM_SLR_UNIT1,BELL,200.99 -BLUEBELL SOLAR (CAPRICORN RIDGE SOLAR),CAPRIDG4_BB_PV,STERLING,30.0 -BLUEBELL SOLAR II 1 (CAPRICORN RIDGE 4),CAPRIDG4_BB2_PV1,STERLING,100.0 -BLUEBELL SOLAR II 2 (CAPRICORN RIDGE 4),CAPRIDG4_BB2_PV2,STERLING,15.0 -BNB LAMESA SOLAR (PHASE I),LMESASLR_UNIT1,DAWSON,101.6 -BNB LAMESA SOLAR (PHASE II),LMESASLR_IVORY,DAWSON,50.0 -BOVINE SOLAR LLC,BOVINE_BOVINE,AUSTIN,5.0 -BOVINE SOLAR LLC,BOVINE2_BOVINE2,AUSTIN,5.0 -BPL FILES SOLAR,FILESSLR_PV1,HILL,146.09 -BRIGHTSIDE SOLAR,BRIGHTSD_UNIT1,BEE,53.4 -BRONSON SOLAR I,BRNSN_BRNSN,FORT BEND,5.0 -BRONSON SOLAR II,BRNSN2_BRNSN2,FORT BEND,5.0 -CASTLE GAP SOLAR,CASL_GAP_UNIT1,UPTON,180.0 -CATAN SOLAR,CS10_CATAN,KARNES,10.0 -CHISUM SOLAR,CHISUM_CHISUM,LAMAR,10.0 -COMMERCE_SOLAR,X443PV1_SWRI_PV1,BEXAR,5.0 -CONIGLIO SOLAR,CONIGLIO_UNIT1,FANNIN,125.7 -CORAL SOLAR U1,CORALSLR_SOLAR1,FALLS,97.7 -CORAL SOLAR U2,CORALSLR_SOLAR2,FALLS,56.3 -CORAZON SOLAR PHASE I,CORAZON_UNIT1,WEBB,202.6 -CROWN SOLAR,CRWN_SLR_UNIT1,FALLS,101.3 -DANCIGER SOLAR U1,DAG_UNIT1,BRAZORIA,101.4 -DANCIGER SOLAR U2,DAG_UNIT2,BRAZORIA,101.4 -DILEO SOLAR,DILEOSLR_UNIT1,BOSQUE,71.4 -EAST BLACKLAND SOLAR (PFLUGERVILLE SOLAR),E_BLACK_UNIT_1,TRAVIS,144.0 -EDDY SOLAR II,EDDYII_EDDYII,MCLENNAN,10.0 -EIFFEL SOLAR,EIFSLR_UNIT1,LAMAR,241.0 -ELARA SOLAR,ELARA_SL_UNIT1,FRIO,132.4 -ELLIS SOLAR,ELLISSLR_UNIT1,ELLIS,81.3 -EMERALD GROVE SOLAR (PECOS SOLAR POWER I),EGROVESL_UNIT1,CRANE,109.5 -EUNICE SOLAR U1,EUNICE_PV1,ANDREWS,189.6 -EUNICE SOLAR U2,EUNICE_PV2,ANDREWS,237.1 -FENCE POST SOLAR U1,FENCESLR_SOLAR1,NAVARRO,138.88 -FENCE POST SOLAR U2,FENCESLR_SOLAR2,NAVARRO,97.98 -FIFTH GENERATION SOLAR 1,FIFTHGS1_FGSOLAR1,TRAVIS,6.8 -FIVE WELLS SOLAR U1,FIVEWSLR_UNIT1,BELL,194.42 -FIVE WELLS SOLAR U2,FIVEWSLR_UNIT2,BELL,126.97 -FOWLER RANCH,FWLR_SLR_UNIT1,CRANE,152.5 -FRYE SOLAR U1,FRYE_SLR_UNIT1,SWISHER,250.9 -FRYE SOLAR U2,FRYE_SLR_UNIT2,SWISHER,251.1 -FS BARILLA SOLAR-PECOS,HOVEY_UNIT1,PECOS,22.0 -FS EAST PECOS SOLAR,BOOTLEG_UNIT1,PECOS,126.0 -GALLOWAY 1 SOLAR,GALLOWAY_SOLAR1,CONCHO,250.0 -GALLOWAY 2 SOLAR,GALLOWAY_SOLAR2,CONCHO,111.1 -GOLINDA SOLAR,GOLINDA_UNIT1,FALLS,101.1 -GREASEWOOD SOLAR 1,GREASWOD_UNIT1,PECOS,126.3 -GREASEWOOD SOLAR 2,GREASWOD_UNIT2,PECOS,132.2 -GRIFFIN SOLAR,GRIFFIN_GRIFFIN,MCLENNAN,5.0 -GRIZZLY RIDGE SOLAR,GRIZZLY_SOLAR1,HAMILTON,101.7 -HALO SOLAR,HALO_SLR_UNIT1,BELL,251.15 -HIGHWAY 56,HWY56_HWY56,GRAYSON,5.3 -HM SEALY SOLAR 1,SEALY_1UNIT,AUSTIN,1.6 -HOLLYWOOD SOLAR U1,HOL_UNIT1,WHARTON,176.14 -HOLLYWOOD SOLAR U2,HOL_UNIT2,WHARTON,178.95 -HOLSTEIN SOLAR 1,HOLSTEIN_SOLAR1,NOLAN,102.2 -HOLSTEIN SOLAR 2,HOLSTEIN_SOLAR2,NOLAN,102.3 -HOPKINS SOLAR U1,HOPKNSLR_UNIT1,HOPKINS,175.35 -HOPKINS SOLAR U2,HOPKNSLR_UNIT2,HOPKINS,76.17 -HORIZON SOLAR,HRZN_SLR_UNIT1,FRIO,203.5 -IMPACT SOLAR,IMPACT_UNIT1,LAMAR,198.5 -JADE SOLAR U1,JADE_SLR_UNIT1,SCURRY,158.8 -JADE SOLAR U2,JADE_SLR_UNIT2,SCURRY,162.4 -JUNO SOLAR PHASE I,JUNO_UNIT1,BORDEN,162.1 -JUNO SOLAR PHASE II,JUNO_UNIT2,BORDEN,143.5 -KELLAM SOLAR,KELAM_SL_UNIT1,VAN ZANDT,59.8 -LAPETUS SOLAR,LAPETUS_UNIT_1,ANDREWS,100.7 -LEON,LEON_LEON,HUNT,10.0 -LILY SOLAR,LILY_SOLAR1,KAUFMAN,147.6 -LONG DRAW SOLAR U1,LGDRAW_S_UNIT1_1,BORDEN,98.5 -LONG DRAW SOLAR U2,LGDRAW_S_UNIT1_2,BORDEN,128.3 -LONGBOW SOLAR,LON_SOLAR1,BRAZORIA,78.2 -MANDORLA SOLAR,MAND_SLR_UNIT1,MILAM,251.45 -MARLIN,MARLIN_MARLIN,FALLS,5.3 -MARS SOLAR (DG),MARS_MARS,WEBB,10.0 -MCLEAN (SHAKES) SOLAR,MCLNSLR_UNIT1,DIMMIT,207.4 -MISAE SOLAR U1,MISAE_UNIT1,CHILDRESS,121.4 -MISAE SOLAR U2,MISAE_UNIT2,CHILDRESS,118.6 -MUSTANG CREEK SOLAR U1,MUSTNGCK_SOLAR1,JACKSON,61.0 -MUSTANG CREEK SOLAR U2,MUSTNGCK_SOLAR2,JACKSON,91.25 -NEBULA SOLAR (RAYOS DEL SOL) U1,NEBULA_UNIT1,CAMERON,137.5 -NOBLE SOLAR U1,NOBLESLR_SOLAR1,DENTON,148.8 -NOBLE SOLAR U2,NOBLESLR_SOLAR2,DENTON,130.2 -NORTH GAINESVILLE,NGNSVL_NGAINESV,COOKE,5.2 -OCI ALAMO 1 SOLAR,OCI_ALM1_UNIT1,BEXAR,39.18 -OCI ALAMO 4 SOLAR-BRACKETVILLE,ECLIPSE_UNIT1,KINNEY,37.62 -OCI ALAMO 5 (DOWNIE RANCH),HELIOS_UNIT1,UVALDE,100.0 -OCI ALAMO 6 (SIRIUS/WEST TEXAS),SIRIUS_UNIT1,PECOS,110.2 -OCI ALAMO 7 (PAINT CREEK),SOLARA_UNIT1,HASKELL,112.0 -PHOEBE SOLAR 1,PHOEBE_UNIT1,WINKLER,125.14 -PHOEBE SOLAR 2,PHOEBE_UNIT2,WINKLER,128.05 -PHOENIX SOLAR,PHOENIX_UNIT1,FANNIN,83.9 -PISGAH RIDGE SOLAR U1,PISGAH_SOLAR1,NAVARRO,189.4 -PISGAH RIDGE SOLAR U2,PISGAH_SOLAR2,NAVARRO,64.4 -PITTS DUDIK SOLAR U1,PITTSDDK_UNIT1,HILL,49.6 -PORTER SOLAR U1,PORT_SLR_UNIT1,DENTON,245.83 -POWERFIN KINGSBERY,PFK_PFKPV,TRAVIS,2.6 -PROSPERO SOLAR 1 U1,PROSPERO_UNIT1,ANDREWS,153.6 -PROSPERO SOLAR 1 U2,PROSPERO_UNIT2,ANDREWS,150.0 -PROSPERO SOLAR 2 U1,PRSPERO2_UNIT1,ANDREWS,126.5 -PROSPERO SOLAR 2 U2,PRSPERO2_UNIT2,ANDREWS,126.4 -QUEEN SOLAR U1,QUEEN_SL_SOLAR1,UPTON,102.5 -QUEEN SOLAR U2,QUEEN_SL_SOLAR2,UPTON,102.5 -QUEEN SOLAR U3,QUEEN_SL_SOLAR3,UPTON,97.5 -QUEEN SOLAR U4,QUEEN_SL_SOLAR4,UPTON,107.5 -RADIAN SOLAR U1,RADN_SLR_UNIT1,BROWN,161.41 -RADIAN SOLAR U2,RADN_SLR_UNIT2,BROWN,166.02 -RAMBLER SOLAR,RAMBLER_UNIT1,TOM GREEN,211.19 -RATLIFF SOLAR (CONCHO VALLEY SOLAR),RATLIFF_SOLAR1,TOM GREEN,162.43 -RE ROSEROCK SOLAR 1,REROCK_UNIT1,PECOS,78.75 -RE ROSEROCK SOLAR 2,REROCK_UNIT2,PECOS,78.75 -REDBARN SOLAR 1 (RE MAPLEWOOD 2A SOLAR),REDBARN_UNIT_1,PECOS,222.0 -REDBARN SOLAR 2 (RE MAPLEWOOD 2B SOLAR),REDBARN_UNIT_2,PECOS,28.0 -RENEWABLE ENERGY ALTERNATIVES-CCS1,COSERVSS_CSS1,DENTON,2.0 -RIGGINS (SE BUCKTHORN WESTEX SOLAR),RIGGINS_UNIT1,PECOS,155.44 -RIPPEY SOLAR,RIPPEY_UNIT1,COOKE,59.8 -ROWLAND SOLAR I,ROW_UNIT1,FORT BEND,101.7 -ROWLAND SOLAR II,ROW_UNIT2,FORT BEND,200.7 -SOLAIREHOLMAN 1,LASSO_UNIT1,BREWSTER,50.0 -SPARTA SOLAR U1,SPARTA_UNIT1,BEE,147.5 -SPARTA SOLAR U2,SPARTA_UNIT2,BEE,104.9 -SP-TX-12-PHASE B,SPTX12B_UNIT1,UPTON,157.5 -STERLING,STRLING_STRLING,HUNT,10.0 -STRATEGIC SOLAR 1,STRATEGC_UNIT1,ELLIS,135.0 -SUN VALLEY U1,SUNVASLR_UNIT1,HILL,165.75 -SUN VALLEY U2,SUNVASLR_UNIT2,HILL,86.19 -SUNRAY,SUN_SLR_UNIT_1,UVALDE,203.5 -TAVENER U1 (FORT BEND SOLAR)                                                                                                                                                                                                                                   ,TAV_UNIT1,FORT BEND,149.5 -TAVENER U2 (FORT BEND SOLAR)                                                                                                                                                                                                                                   ,TAV_UNIT2,FORT BEND,100.4 -TAYGETE SOLAR 1 U1,TAYGETE_UNIT1,PECOS,125.9 -TAYGETE SOLAR 1 U2,TAYGETE_UNIT2,PECOS,128.9 -TAYGETE SOLAR 2 U1,TAYGETE2_UNIT1,PECOS,101.9 -TAYGETE SOLAR 2 U2,TAYGETE2_UNIT2,PECOS,101.9 -TEXAS SOLAR NOVA U1,NOVA1SLR_UNIT1,KENT,126.81 -TEXAS SOLAR NOVA U2,NOVA1SLR_UNIT2,KENT,126.7 -TIERRA BONITA SOLAR U1,TRBT_SLR_PV1,PECOS,150.0 -TIERRA BONITA SOLAR U2,TRBT_SLR_PV2,PECOS,156.9 -TITAN SOLAR (IP TITAN) U1,TI_SOLAR_UNIT1,CULBERSON,136.8 -TITAN SOLAR (IP TITAN) U2,TI_SOLAR_UNIT2,CULBERSON,131.1 -TPE ERATH SOLAR,ERATH_ERATH21,ERATH,10.0 -TRUE NORTH SOLAR U1,TNS_SLR_UNIT1,FALLS,119.35 -TRUE NORTH SOLAR U2,TNS_SLR_UNIT2,FALLS,119.45 -VANCOURT SOLAR,VANCOURT_UNIT1,CAMERON,45.7 -VISION SOLAR 1,VISION_UNIT1,NAVARRO,129.2 -WAGYU SOLAR,WGU_UNIT1,BRAZORIA,120.0 -WALNUT SPRINGS,WLNTSPRG_1UNIT,BOSQUE,10.0 -WAYMARK SOLAR,WAYMARK_UNIT1,UPTON,182.0 -WEBBERVILLE SOLAR,WEBBER_S_WSP1,TRAVIS,26.7 -WEST MOORE II,WMOOREII_WMOOREII,GRAYSON,5.0 -WEST OF PECOS SOLAR,W_PECOS_UNIT1,REEVES,100.0 -WESTORIA SOLAR U1,WES_UNIT1,BRAZORIA,101.6 -WESTORIA SOLAR U2,WES_UNIT2,BRAZORIA,101.6 -WHITESBORO,WBORO_WHTSBORO,GRAYSON,5.0 -WHITESBORO II,WBOROII_WHBOROII,GRAYSON,5.0 -WHITEWRIGHT,WHTRT_WHTRGHT,FANNIN,10.0 -YELLOW JACKET SOLAR,YLWJACKET_YLWJACKET,BOSQUE,5.0 -ZIER SOLAR,ZIER_SLR_PV1,KINNEY,161.28 -ASH CREEK SOLAR U1,ASCK_SLR_SOLAR1,HILL,206.8 -ASH CREEK SOLAR U2,ASCK_SLR_SOLAR2,HILL,210.94 -AZALEA SPRINGS SOLAR,AZSP_SLR_SOLAR1,ANGELINA,181.0 -BAKER BRANCH SOLAR U1,BAKE_SLR_UNIT1,LAMAR,234.84 -BAKER BRANCH SOLAR U2,BAKE_SLR_UNIT2,LAMAR,234.57 -BIG STAR SOLAR U1,BIG_STAR_UNIT1,BASTROP,132.27 -BIG STAR SOLAR U2,BIG_STAR_UNIT2,BASTROP,70.83 -BLEVINS SOLAR U2,BLVN_SLR_SOLAR2,FALLS,132.02 -BLEVINS SOLAR U3,BLVN_SLR_SOLAR3,FALLS,139.74 -BLUE JAY SOLAR I,BLUEJAY_UNIT1,GRIMES,69.0 -BLUE JAY SOLAR II,BLUEJAY_UNIT2,GRIMES,141.0 -BRIGHT ARROW SOLAR U1,BR_ARROW_UNIT1,HOPKINS,127.3 -BRIGHT ARROW SOLAR U2,BR_ARROW_UNIT2,HOPKINS,173.9 -BUFFALO CREEK (OLD 300 SOLAR CENTER) U1,BCK_UNIT1,FORT BEND,217.5 -BUFFALO CREEK (OLD 300 SOLAR CENTER) U2,BCK_UNIT2,FORT BEND,221.3 -CHEVRON ALLEN SOLAR (HAYHURST TEXAS SOLAR),CHAL_SLR_SOLAR1,CULBERSON,25.22 -CHILLINGHAM SOLAR U1,CHIL_SLR_SOLAR1,BELL,174.3 -CHILLINGHAM SOLAR U2,CHIL_SLR_SOLAR2,BELL,178.1 -COMPADRE SOLAR U1,CMPD_SLR_SOLAR1,HILL,195.17 -COMPADRE SOLAR U2,CMPD_SLR_SOLAR2,HILL,211.37 -COTTONWOOD BAYOU SOLAR I U1,CTW_SOLAR1,BRAZORIA,175.69 -COTTONWOOD BAYOU SOLAR I U2,CTW_SOLAR2,BRAZORIA,175.71 -DAMAZO (SECOND DIVISION) SOLAR,DMA_SOLAR1,BRAZORIA,100.2 -DANISH FIELDS SOLAR U1,DAN_UNIT1,WHARTON,301.3 -DANISH FIELDS SOLAR U2,DAN_UNIT2,WHARTON,151.0 -DANISH FIELDS SOLAR U3,DAN_UNIT3,WHARTON,150.5 -DELILAH SOLAR 1 U1,DELILA_1_G1,LAMAR,153.54 -DELILAH SOLAR 1 U2,DELILA_1_G2,LAMAR,153.54 -DELILAH SOLAR 2 U1,DELILA_2_G1,RED RIVER,107.09 -DELILAH SOLAR 2 U2,DELILA_2_G2,RED RIVER,103.4 -DELILAH SOLAR 2 U3,DELILA_2_G3,RED RIVER,107.09 -DRY CREEK SOLAR I,DRCK_SLR_SOLAR1,HENDERSON,200.1 -EASTBELL MILAM SOLAR,EBELLSLR_UNIT1,MILAM,244.86 -EASTBELL MILAM SOLAR II,EBELLSL2_UNIT1,MILAM,150.6 -ELIZA SOLAR,ELZA_SLR_SOLAR1,KAUFMAN,151.7 -ESTONIAN SOLAR FARM U1,ESTONIAN_SOLAR1,DELTA,88.4 -ESTONIAN SOLAR FARM U2,ESTONIAN_SOLAR2,DELTA,114.4 -FIGHTING JAYS SOLAR U1,JAY_UNIT1,FORT BEND,179.6 -FIGHTING JAYS SOLAR U2,JAY_UNIT2,FORT BEND,171.9 -GRANSOLAR TEXAS ONE,GRAN_SLR_UNIT1,MILAM,50.19 -GRIMES COUNTY SOLAR U1,GRIM_SLR_UNIT1,GRIMES,104.46 -GRIMES COUNTY SOLAR U2,GRIM_SLR_UNIT2,GRIMES,79.87 -GRIMES COUNTY SOLAR U3,GRIM_SLR_UNIT3,GRIMES,26.92 -HORNET SOLAR U1,HRNT_SLR_UNIT1,SWISHER,202.09 -HORNET SOLAR U2,HRNT_SLR_UNIT2,SWISHER,200.54 -HORNET SOLAR U3,HRNT_SLR_UNIT3,SWISHER,201.18 -HOVEY (BARILLA SOLAR 1B),HOVEY_UNIT2,PECOS,7.41 -JUNGMANN SOLAR,JUNG_SLR_UNIT1,MILAM,40.21 -MARKUM SOLAR,MRKM_SLR_PV1,MCLENNAN,161.5 -MERCURY SOLAR U1,MERCURY_PV1,HILL,203.5 -MERCURY SOLAR U2,MERCURY_PV2,HILL,203.5 -MORROW LAKE SOLAR,MROW_SLR_SOLAR1,FRIO,202.2 -MYRTLE SOLAR U1,MYR_UNIT1,BRAZORIA,171.6 -MYRTLE SOLAR U2,MYR_UNIT2,BRAZORIA,149.6 -ORANGE GROVE SOLAR,OGS_SLR_UNIT1,JIM WELLS,130.6 -OUTPOST SOLAR U1,OUTP_SLR_UNIT1,WEBB,257.95 -OUTPOST SOLAR U2,OUTP_SLR_UNIT2,WEBB,259.11 -PEREGRINE SOLAR U1,PERE_SLR_UNIT1,GOLIAD,152.83 -PEREGRINE SOLAR U2,PERE_SLR_UNIT2,GOLIAD,148.28 -PHOTON SOLAR U1,PHO_SOLAR1,WHARTON,129.59 -PHOTON SOLAR U2,PHO_SOLAR2,WHARTON,106.07 -PHOTON SOLAR U3,PHO_SOLAR3,WHARTON,109.99 -PHOTON SOLAR U4,PHO_SOLAR4,WHARTON,105.98 -PLAINVIEW SOLAR (RAMSEY SOLAR) U1,PLN_UNIT1,WHARTON,270.0 -PLAINVIEW SOLAR (RAMSEY SOLAR) U2,PLN_UNIT2,WHARTON,270.0 -ROSELAND SOLAR U1,ROSELAND_SOLAR1,FALLS,254.0 -ROSELAND SOLAR U2,ROSELAND_SOLAR2,FALLS,137.8 -ROSELAND SOLAR U3,ROSELAND_SOLAR3,FALLS,116.2 -SAMSON SOLAR 1 U1,SAMSON_1_G1,LAMAR,128.42 -SAMSON SOLAR 1 U2,SAMSON_1_G2,LAMAR,128.42 -SAMSON SOLAR 2 U1,SAMSON_1_G3,LAMAR,101.52 -SAMSON SOLAR 2 U2,SAMSON_1_G4,LAMAR,101.52 -SAMSON SOLAR 3 U1,SAMSON_3_G1,LAMAR,128.42 -SAMSON SOLAR 3 U2,SAMSON_3_G2,LAMAR,128.42 -SBRANCH SOLAR PROJECT,SBE_UNIT1,WHARTON,233.5 -SIGNAL SOLAR,SIG_SLR_UNIT1,HUNT,51.6 -STAMPEDE SOLAR U1,STAM_SLR_SOLAR1,HOPKINS,77.75 -STAMPEDE SOLAR U2,STAM_SLR_SOLAR2,HOPKINS,178.55 -STARR SOLAR RANCH U1,STAR_SLR_UNIT1,STARR,70.45 -STARR SOLAR RANCH U2,STAR_SLR_UNIT2,STARR,66.28 -STONERIDGE SOLAR U1,STRG_SLR_UNIT1,MILAM,184.1 -STONERIDGE SOLAR U2,STRG_SLR_UNIT2,MILAM,17.5 -SWIFT AIR SOLAR,SWFT_SLR_UNIT1,ECTOR,146.5 -TEXAS SOLAR NOVA 2 U1,NOVA2SLR_UNIT1,KENT,202.37 -TRES BAHIAS SOLAR,TREB_SLR_SOLAR1,CALHOUN,196.29 -TULSITA SOLAR U1,TUL_SLR_UNIT1,GOLIAD,128.08 -TULSITA SOLAR U2,TUL_SLR_UNIT2,GOLIAD,128.12 -XE MURAT [ADLONG] SOLAR,ADL_SOLAR1,HARRIS,60.14 -PHOEBE SOLAR 1,PHOEBE_UNIT1,WINKLER,125.04 -PHOEBE SOLAR 2,PHOEBE_UNIT2,WINKLER,127.95 -FIGHTING JAYS SOLAR U1,JAY_UNIT1,FORT BEND,179.5 -FIGHTING JAYS SOLAR U2,JAY_UNIT2,FORT BEND,171.8 -HORNET SOLAR U1,HRNT_SLR_UNIT1,SWISHER,200.65 -CASCADE SOLAR I,CASCADE_CASCADE,WHARTON,5.0 -CASCADE SOLAR II,CASCADE2_CASCADE2,WHARTON,5.0 -LAMPWICK SOLAR,LAMPWICK_LAMPWICK,MENARD,7.5 -MARLIN,MARLIN_MARLIN,FALLS,5.28 -TPE ERATH SOLAR,ERATH_ERATH21,ERATH,9.99 -CASCADE SOLAR I,CASCADE_CASCADE,WHARTON,177.52 -BLUE WING 1 SOLAR,DG_BROOK_1UNIT,BEXAR,7.6 -BLUE WING 2 SOLAR,DG_ELMEN_1UNIT,BEXAR,7.3 -OCI ALAMO 2 SOLAR-ST. HEDWIG,DG_STHWG_UNIT1,BEXAR,4.4 -OCI ALAMO 3-WALZEM SOLAR,DG_WALZM_UNIT1,BEXAR,5.5 -SUNEDISON CPS3 SOMERSET 1 SOLAR,DG_SOME1_1UNIT,BEXAR,5.6 -SUNEDISON RABEL ROAD SOLAR,DG_VALL1_1UNIT,BEXAR,9.9 -SUNEDISON SOMERSET 2 SOLAR,DG_SOME2_1UNIT,BEXAR,5.0 -SUNEDISON VALLEY ROAD SOLAR,DG_VALL2_1UNIT,BEXAR,9.9 -WHITNEY SOLAR,DG_WHITNEY_SOLAR1,BOSQUE,10.0 -7V SOLAR U1,7RNCHSLR_UNIT1,FAYETTE,139.66 -7V SOLAR,7RNCHSLR_UNIT1,FAYETTE,139.66 -COMPADRE SOLAR U1,CMPD_SLR_SOLAR1,HILL,194.5 -COMPADRE SOLAR U2,CMPD_SLR_SOLAR2,HILL,211.2 -EASTBELL MILAM SOLAR II,EBELLSL2_UNIT1,MILAM,150.0 -PEREGRINE SOLAR U1,PERE_SLR_UNIT1,GOLIAD,152.2 -PEREGRINE SOLAR U2,PERE_SLR_UNIT2,GOLIAD,147.7 -PHOTON SOLAR U4,PHO_SOLAR4,WHARTON,105.7 -SIGNAL SOLAR,SIG_SLR_UNIT1,HUNT,50.0 -XE MURAT [ADLONG] SOLAR,ADL_SOLAR1,HARRIS,60.0 -JACKALOPE SOLAR U1,JKLP_SLR_PV1,SAN PATRICIO,81.38 -JACKALOPE SOLAR U2,JKLP_SLR_PV2,SAN PATRICIO,71.74 -TEXAS BLUEBONNET SOLAR,BONETSLR_UNIT1,MCLENNAN,9.75 diff --git a/data/slurm_outputs/herbie_13573894.err b/data/slurm_outputs/herbie_13573894.err index 4fcfd8cc..d4239b07 100644 --- a/data/slurm_outputs/herbie_13573894.err +++ b/data/slurm_outputs/herbie_13573894.err @@ -41322,3 +41322,1341 @@ dsi = ds.herbie.nearest_points(points=points, /kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:03,271 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 18 hr time horizon... +2026-04-29 09:19:03,290 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 4 hr time horizon... +2026-04-29 09:19:03,620 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 10 hr time horizon... +2026-04-29 09:19:03,640 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:11,717 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 7 hr time horizon... +2026-04-29 09:19:11,735 - __main__ - INFO - Processing values: 2018-01-01 21:00:00 18 hr time horizon... +2026-04-29 09:19:11,806 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 15 hr time horizon... +2026-04-29 09:19:11,824 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:12,425 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 14 hr time horizon... +2026-04-29 09:19:12,442 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:15,246 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 9 hr time horizon... +2026-04-29 09:19:15,266 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:15,412 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 18 hr time horizon... +2026-04-29 09:19:15,430 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:15,715 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:15,736 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:16,228 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 12 hr time horizon... +2026-04-29 09:19:16,246 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:16,731 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 14 hr time horizon... +2026-04-29 09:19:16,751 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:18,112 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 14 hr time horizon... +2026-04-29 09:19:18,130 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:18,438 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 17 hr time horizon... +2026-04-29 09:19:18,457 - __main__ - INFO - Processing values: 2018-01-27 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:18,656 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 11 hr time horizon... +2026-04-29 09:19:18,679 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:19,876 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 15 hr time horizon... +2026-04-29 09:19:19,898 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:24,235 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 3 hr time horizon... +2026-04-29 09:19:24,255 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:25,343 - __main__ - INFO - Finished processing 2018-01-01 21:00:00 18 hr time horizon... +2026-04-29 09:19:25,367 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:25,921 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 16 hr time horizon... +2026-04-29 09:19:25,941 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:28,231 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 10 hr time horizon... +2026-04-29 09:19:28,250 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 4 hr time horizon... +2026-04-29 09:19:28,260 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:28,281 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:29,619 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 15 hr time horizon... +2026-04-29 09:19:29,639 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 5 hr time horizon... +2026-04-29 09:19:29,663 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:29,684 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:30,070 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 16 hr time horizon... +2026-04-29 09:19:30,090 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:30,334 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 7 hr time horizon... +2026-04-29 09:19:30,351 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:31,833 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 14 hr time horizon... +2026-04-29 09:19:31,858 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:32,291 - __main__ - INFO - Finished processing 2018-01-27 20:00:00 18 hr time horizon... +2026-04-29 09:19:32,316 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:32,426 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 11 hr time horizon... +2026-04-29 09:19:32,446 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:33,256 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 8 hr time horizon... +2026-04-29 09:19:33,278 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 7 hr time horizon... +2026-04-29 09:19:33,798 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 13 hr time horizon... +2026-04-29 09:19:33,823 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:37,746 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:37,767 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:38,994 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:39,015 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:40,326 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 6 hr time horizon... +2026-04-29 09:19:40,346 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:41,569 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 12 hr time horizon... +2026-04-29 09:19:41,591 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:42,250 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 11 hr time horizon... +2026-04-29 09:19:42,280 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:42,508 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 4 hr time horizon... +2026-04-29 09:19:42,533 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:43,316 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:43,338 - __main__ - INFO - Processing values: 2018-01-11 12:00:00 4 hr time horizon... +2026-04-29 09:19:43,547 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 5 hr time horizon... +2026-04-29 09:19:43,578 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:43,643 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 16 hr time horizon... +2026-04-29 09:19:43,668 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:43,793 - __main__ - INFO - Finished processing 2018-01-14 21:00:00 9 hr time horizon... +2026-04-29 09:19:43,815 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 4 hr time horizon... +2026-04-29 09:19:43,868 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 4 hr time horizon... +2026-04-29 09:19:43,887 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:45,712 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 10 hr time horizon... +2026-04-29 09:19:45,733 - __main__ - INFO - Processing values: 2018-01-22 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:45,984 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 14 hr time horizon... +2026-04-29 09:19:46,007 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:47,268 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 7 hr time horizon... +2026-04-29 09:19:47,294 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 14 hr time horizon... +2026-04-29 09:19:47,329 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 11 hr time horizon... +2026-04-29 09:19:47,349 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 2 hr time horizon... +2026-04-29 09:19:47,842 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 1 hr time horizon... +2026-04-29 09:19:47,864 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() From 64c031a504a16baac69d2a6bca8e854e71250d8e Mon Sep 17 00:00:00 2001 From: kperry Date: Wed, 29 Apr 2026 15:04:37 -0600 Subject: [PATCH 17/17] added slurm calls to gitignore, updated script to run specifically for wind sites --- .gitignore | 5 +- data/generate_herbie_forecasts.py | 17 +- data/slurm_outputs/herbie_13573894.err | 135047 ++++++++++++++++++++++ 3 files changed, 135060 insertions(+), 9 deletions(-) diff --git a/.gitignore b/.gitignore index 129f6d67..cc535e85 100644 --- a/.gitignore +++ b/.gitignore @@ -8,8 +8,9 @@ __pycache__/ # C extensions *.so - -# Distribution / packaging +*.err +*.out +r Distribution / packaging .Python build/ develop-eggs/ diff --git a/data/generate_herbie_forecasts.py b/data/generate_herbie_forecasts.py index 670e4c97..2a7ef2cd 100644 --- a/data/generate_herbie_forecasts.py +++ b/data/generate_herbie_forecasts.py @@ -35,13 +35,13 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): fxx=time_horizon ) file = H.download() - # ":TCDC:entire atmosphere:anl": overall cloud cover + #:TCDC:entire atmosphere:anl: overall cloud cover #:UGRD:80 m above ground:anl: u-component wind speed (80 m above ground) #:VGRD:80 m above ground:anl: v-component wind speed (80 m above ground) - #":RH:2 m above ground:anl": relative humidity at surface - #TMP:surface:anl: surface temperature + #:RH:2 m above ground:anl: relative humidity at surface + #:TMP:surface:anl: surface temperature #:PRES:surface:anl: surface pressure - #DPT:2 m above ground:anl: dew point + #:DPT:2 m above ground:anl: dew point # Full list of options: https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/HRRR_archive/hrrr_sfc_table_f00-f01.html tags = [":TCDC:entire atmosphere:" + str(time_horizon) + " hour fcst", ":UGRD:80 m above ground:" + str(time_horizon) + " hour fcst", @@ -58,7 +58,7 @@ def pull_herbie_hrr_data(date, time_horizon, aws_profile): names=names) # Build out a dataframe for the predictions pred_df = pd.DataFrame() - pred_df['county'] = list(dsi.point.values) + pred_df['wind_site_name'] = list(dsi.point.values) pred_df['point_latitude'] = list(dsi.point_latitude.values) pred_df['point_longitude'] = list(dsi.point_longitude.values) pred_df['tag'] = tag @@ -206,9 +206,12 @@ def pull_herbie_gefs_data(date, time_horizon, aws_profile): file_keys.append(obj['Key']) existing_files = [os.path.basename(x) for x in file_keys] # Read in the nodes we want to forecast on - df = pd.read_csv("nodes.csv") + df = pd.read_csv("uswtdb.csv") + df['Lat'] = df.groupby("name")['latitude'].transform('mean') + df['Long'] = df.groupby("name")['longitude'].transform('mean') + df = df[['name', 'Lat', "Long"]].drop_duplicates() points = [(y,x) for x,y in zip(df['Lat'], df['Long'])] - names = list(df['county']) + names = list(df['name']) master_prediction_df = pd.DataFrame() # Create a logger logger = logging.getLogger(__name__) diff --git a/data/slurm_outputs/herbie_13573894.err b/data/slurm_outputs/herbie_13573894.err index d4239b07..2178ca5d 100644 --- a/data/slurm_outputs/herbie_13573894.err +++ b/data/slurm_outputs/herbie_13573894.err @@ -42660,3 +42660,135050 @@ dsi = ds.herbie.nearest_points(points=points, /kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:52,469 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 10 hr time horizon... +2026-04-29 09:19:52,491 - __main__ - INFO - Processing values: 2018-01-16 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:54,464 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 12 hr time horizon... +2026-04-29 09:19:54,486 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:55,105 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:55,130 - __main__ - INFO - Processing values: 2018-01-21 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:55,434 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 8 hr time horizon... +2026-04-29 09:19:55,453 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:55,817 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 5 hr time horizon... +2026-04-29 09:19:55,843 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 10 hr time horizon... +2026-04-29 09:19:55,901 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:55,926 - __main__ - INFO - Processing values: 2018-01-10 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:56,420 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 9 hr time horizon... +2026-04-29 09:19:56,443 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:57,301 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 13 hr time horizon... +2026-04-29 09:19:57,322 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:57,506 - __main__ - INFO - Finished processing 2018-01-11 12:00:00 4 hr time horizon... +2026-04-29 09:19:57,531 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:58,114 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 3 hr time horizon... +2026-04-29 09:19:58,136 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:58,810 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:58,834 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:19:59,045 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 4 hr time horizon... +2026-04-29 09:19:59,067 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:00,424 - __main__ - INFO - Finished processing 2018-01-22 22:00:00 16 hr time horizon... +2026-04-29 09:20:00,449 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:00,675 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 14 hr time horizon... +2026-04-29 09:20:00,699 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:01,546 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 14 hr time horizon... +2026-04-29 09:20:01,570 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:02,040 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 10 hr time horizon... +2026-04-29 09:20:02,062 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 5 hr time horizon... +2026-04-29 09:20:02,163 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 2 hr time horizon... +2026-04-29 09:20:02,185 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:02,921 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 1 hr time horizon... +2026-04-29 09:20:02,941 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:06,721 - __main__ - INFO - Finished processing 2018-01-16 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:06,742 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:09,744 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:09,752 - __main__ - INFO - Finished processing 2018-01-21 10:00:00 11 hr time horizon... +2026-04-29 09:20:09,769 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 10 hr time horizon... +2026-04-29 09:20:09,776 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:09,913 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 5 hr time horizon... +2026-04-29 09:20:09,938 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:10,328 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:10,350 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:10,469 - __main__ - INFO - Finished processing 2018-01-10 23:00:00 1 hr time horizon... +2026-04-29 09:20:10,491 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:11,243 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 12 hr time horizon... +2026-04-29 09:20:11,266 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:11,910 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:11,935 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:13,345 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 5 hr time horizon... +2026-04-29 09:20:13,347 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 2 hr time horizon... +2026-04-29 09:20:13,373 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 12 hr time horizon... +2026-04-29 09:20:13,374 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:13,461 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 14 hr time horizon... +2026-04-29 09:20:13,484 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:14,547 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:14,568 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:15,629 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:15,652 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 14 hr time horizon... +2026-04-29 09:20:15,652 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 3 hr time horizon... +2026-04-29 09:20:15,687 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:16,762 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:16,787 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 12 hr time horizon... +2026-04-29 09:20:16,862 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 18 hr time horizon... +2026-04-29 09:20:16,883 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 7 hr time horizon... +2026-04-29 09:20:17,003 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 5 hr time horizon... +2026-04-29 09:20:17,033 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 16 hr time horizon... +2026-04-29 09:20:17,376 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 7 hr time horizon... +2026-04-29 09:20:17,400 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:23,472 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:23,501 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:23,832 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 10 hr time horizon... +2026-04-29 09:20:23,858 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:24,328 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:24,357 - __main__ - INFO - Processing values: 2018-01-19 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:25,361 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 16 hr time horizon... +2026-04-29 09:20:25,386 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:25,461 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 7 hr time horizon... +2026-04-29 09:20:25,485 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:25,668 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 7 hr time horizon... +2026-04-29 09:20:25,693 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:26,929 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 18 hr time horizon... +2026-04-29 09:20:26,950 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:27,249 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:27,279 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:27,916 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 15 hr time horizon... +2026-04-29 09:20:27,935 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:28,155 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 12 hr time horizon... +2026-04-29 09:20:28,180 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:28,818 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:28,846 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:30,166 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:30,190 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:30,388 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 11 hr time horizon... +2026-04-29 09:20:30,413 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:31,888 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 8 hr time horizon... +2026-04-29 09:20:31,916 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 5 hr time horizon... +2026-04-29 09:20:31,982 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 7 hr time horizon... +2026-04-29 09:20:32,005 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:32,482 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 4 hr time horizon... +2026-04-29 09:20:32,505 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:35,215 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 16 hr time horizon... +2026-04-29 09:20:35,238 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:36,847 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 12 hr time horizon... +2026-04-29 09:20:36,869 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:37,874 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:37,900 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 5 hr time horizon... +2026-04-29 09:20:37,923 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 11 hr time horizon... +2026-04-29 09:20:37,943 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:39,150 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 6 hr time horizon... +2026-04-29 09:20:39,174 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:39,264 - __main__ - INFO - Finished processing 2018-01-19 05:00:00 5 hr time horizon... +2026-04-29 09:20:39,286 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:39,749 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 1 hr time horizon... +2026-04-29 09:20:39,765 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:40,836 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 5 hr time horizon... +2026-04-29 09:20:40,858 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:41,027 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 18 hr time horizon... +2026-04-29 09:20:41,049 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:42,896 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 3 hr time horizon... +2026-04-29 09:20:42,921 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:43,808 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 11 hr time horizon... +2026-04-29 09:20:43,841 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:43,887 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 12 hr time horizon... +2026-04-29 09:20:43,911 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:44,708 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 7 hr time horizon... +2026-04-29 09:20:44,728 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:45,167 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:45,186 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:45,773 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 5 hr time horizon... +2026-04-29 09:20:45,794 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 13 hr time horizon... +2026-04-29 09:20:45,901 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 16 hr time horizon... +2026-04-29 09:20:45,927 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:46,135 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 4 hr time horizon... +2026-04-29 09:20:46,154 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:46,669 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 5 hr time horizon... +2026-04-29 09:20:46,691 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:48,510 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 2 hr time horizon... +2026-04-29 09:20:48,528 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:51,768 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 7 hr time horizon... +2026-04-29 09:20:51,792 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:51,930 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:51,960 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:52,966 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 10 hr time horizon... +2026-04-29 09:20:52,987 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:54,159 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 15 hr time horizon... +2026-04-29 09:20:54,184 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 8 hr time horizon... +2026-04-29 09:20:54,254 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:54,274 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:54,400 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 10 hr time horizon... +2026-04-29 09:20:54,420 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:54,948 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 3 hr time horizon... +2026-04-29 09:20:54,968 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:55,215 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 5 hr time horizon... +2026-04-29 09:20:55,237 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:57,292 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 12 hr time horizon... +2026-04-29 09:20:57,318 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:58,978 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 3 hr time horizon... +2026-04-29 09:20:59,003 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:20:59,377 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 1 hr time horizon... +2026-04-29 09:20:59,396 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:00,101 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 10 hr time horizon... +2026-04-29 09:21:00,123 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 12 hr time horizon... +2026-04-29 09:21:00,200 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 5 hr time horizon... +2026-04-29 09:21:00,222 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:00,624 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 2 hr time horizon... +2026-04-29 09:21:00,643 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:02,401 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 13 hr time horizon... +2026-04-29 09:21:02,419 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:03,661 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 15 hr time horizon... +2026-04-29 09:21:03,682 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:05,125 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 9 hr time horizon... +2026-04-29 09:21:05,145 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:07,599 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 11 hr time horizon... +2026-04-29 09:21:07,620 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:07,997 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 6 hr time horizon... +2026-04-29 09:21:08,014 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 10 hr time horizon... +2026-04-29 09:21:08,127 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:08,146 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:08,499 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 15 hr time horizon... +2026-04-29 09:21:08,520 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:10,684 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 2 hr time horizon... +2026-04-29 09:21:10,710 - __main__ - INFO - Processing values: 2018-01-16 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:12,155 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 1 hr time horizon... +2026-04-29 09:21:12,184 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:13,001 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 18 hr time horizon... +2026-04-29 09:21:13,022 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:13,158 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 10 hr time horizon... +2026-04-29 09:21:13,178 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:13,594 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 12 hr time horizon... +2026-04-29 09:21:13,617 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:14,584 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 15 hr time horizon... +2026-04-29 09:21:14,623 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:14,989 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 3 hr time horizon... +2026-04-29 09:21:15,009 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:15,489 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:15,509 - __main__ - INFO - Processing values: 2018-01-02 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:17,548 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 5 hr time horizon... +2026-04-29 09:21:17,567 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 9 hr time horizon... +2026-04-29 09:21:17,597 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 2 hr time horizon... +2026-04-29 09:21:17,616 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 15 hr time horizon... +2026-04-29 09:21:17,707 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 7 hr time horizon... +2026-04-29 09:21:17,729 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:18,421 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:18,443 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:20,675 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 3 hr time horizon... +2026-04-29 09:21:20,697 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:21,203 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 10 hr time horizon... +2026-04-29 09:21:21,224 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:23,433 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 9 hr time horizon... +2026-04-29 09:21:23,458 - __main__ - INFO - Processing values: 2018-01-01 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:23,565 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 9 hr time horizon... +2026-04-29 09:21:23,587 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:24,790 - __main__ - INFO - Finished processing 2018-01-16 11:00:00 4 hr time horizon... +2026-04-29 09:21:24,814 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:25,328 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 10 hr time horizon... +2026-04-29 09:21:25,348 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:27,054 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 8 hr time horizon... +2026-04-29 09:21:27,075 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:28,677 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:28,698 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 18 hr time horizon... +2026-04-29 09:21:28,715 - __main__ - INFO - Finished processing 2018-01-02 12:00:00 5 hr time horizon... +2026-04-29 09:21:28,735 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:29,258 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 12 hr time horizon... +2026-04-29 09:21:29,282 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:30,034 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 16 hr time horizon... +2026-04-29 09:21:30,064 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:30,877 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 15 hr time horizon... +2026-04-29 09:21:30,897 - __main__ - INFO - Processing values: 2018-01-11 15:00:00 15 hr time horizon... +2026-04-29 09:21:30,974 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 9 hr time horizon... +2026-04-29 09:21:30,995 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:31,748 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 15 hr time horizon... +2026-04-29 09:21:31,767 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:34,558 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 7 hr time horizon... +2026-04-29 09:21:34,589 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:35,084 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 5 hr time horizon... +2026-04-29 09:21:35,105 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:36,640 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 14 hr time horizon... +2026-04-29 09:21:36,669 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:37,330 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:37,351 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:37,605 - __main__ - INFO - Finished processing 2018-01-01 21:00:00 11 hr time horizon... +2026-04-29 09:21:37,630 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:37,973 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 13 hr time horizon... +2026-04-29 09:21:37,992 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:38,442 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 7 hr time horizon... +2026-04-29 09:21:38,461 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:39,464 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 16 hr time horizon... +2026-04-29 09:21:39,489 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:39,938 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 5 hr time horizon... +2026-04-29 09:21:39,958 - __main__ - INFO - Processing values: 2018-01-27 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:41,970 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 9 hr time horizon... +2026-04-29 09:21:41,990 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:42,279 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 18 hr time horizon... +2026-04-29 09:21:42,299 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 2 hr time horizon... +2026-04-29 09:21:42,400 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 3 hr time horizon... +2026-04-29 09:21:42,419 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:44,237 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 10 hr time horizon... +2026-04-29 09:21:44,262 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:44,359 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 8 hr time horizon... +2026-04-29 09:21:44,380 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:45,497 - __main__ - INFO - Finished processing 2018-01-11 15:00:00 15 hr time horizon... +2026-04-29 09:21:45,520 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:46,332 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 11 hr time horizon... +2026-04-29 09:21:46,355 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:48,360 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 3 hr time horizon... +2026-04-29 09:21:48,380 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:48,608 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:48,631 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:50,009 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:50,032 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:51,149 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 18 hr time horizon... +2026-04-29 09:21:51,172 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:51,482 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 10 hr time horizon... +2026-04-29 09:21:51,508 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:51,904 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 12 hr time horizon... +2026-04-29 09:21:51,925 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 1 hr time horizon... +2026-04-29 09:21:52,102 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 18 hr time horizon... +2026-04-29 09:21:52,123 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:52,776 - __main__ - INFO - Finished processing 2018-01-27 01:00:00 1 hr time horizon... +2026-04-29 09:21:52,795 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:55,106 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 5 hr time horizon... +2026-04-29 09:21:55,126 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:55,596 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 10 hr time horizon... +2026-04-29 09:21:55,614 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 10 hr time horizon... +2026-04-29 09:21:56,022 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 2 hr time horizon... +2026-04-29 09:21:56,045 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 9 hr time horizon... +2026-04-29 09:21:56,138 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 14 hr time horizon... +2026-04-29 09:21:56,160 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:59,183 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 10 hr time horizon... +2026-04-29 09:21:59,206 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 3 hr time horizon... +2026-04-29 09:21:59,288 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 12 hr time horizon... +2026-04-29 09:21:59,312 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:21:59,666 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 13 hr time horizon... +2026-04-29 09:21:59,691 - __main__ - INFO - Processing values: 2018-01-15 23:00:00 5 hr time horizon... +2026-04-29 09:21:59,765 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 11 hr time horizon... +2026-04-29 09:21:59,785 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:02,167 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 16 hr time horizon... +2026-04-29 09:22:02,191 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:02,667 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 8 hr time horizon... +2026-04-29 09:22:02,693 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:03,444 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 15 hr time horizon... +2026-04-29 09:22:03,468 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:04,924 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 8 hr time horizon... +2026-04-29 09:22:04,946 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:05,140 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 17 hr time horizon... +2026-04-29 09:22:05,163 - __main__ - INFO - Processing values: 2018-01-10 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:05,458 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 1 hr time horizon... +2026-04-29 09:22:05,476 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:22:06,021 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:06,054 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:08,095 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 6 hr time horizon... +2026-04-29 09:22:08,118 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:08,803 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 9 hr time horizon... +2026-04-29 09:22:08,825 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:09,288 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 3 hr time horizon... +2026-04-29 09:22:09,308 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 9 hr time horizon... +2026-04-29 09:22:09,412 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 10 hr time horizon... +2026-04-29 09:22:09,432 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:10,169 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 9 hr time horizon... +2026-04-29 09:22:10,189 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:12,431 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 15 hr time horizon... +2026-04-29 09:22:12,449 - __main__ - INFO - Finished processing 2018-01-15 23:00:00 5 hr time horizon... +2026-04-29 09:22:12,459 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 13 hr time horizon... +2026-04-29 09:22:12,469 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:13,476 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 18 hr time horizon... +2026-04-29 09:22:13,497 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 5 hr time horizon... +2026-04-29 09:22:13,570 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 3 hr time horizon... +2026-04-29 09:22:13,590 - __main__ - INFO - Processing values: 2018-01-08 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:16,461 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 11 hr time horizon... +2026-04-29 09:22:16,484 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:17,932 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 16 hr time horizon... +2026-04-29 09:22:17,956 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:18,572 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 8 hr time horizon... +2026-04-29 09:22:18,593 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 2 hr time horizon... +2026-04-29 09:22:18,607 - __main__ - INFO - Finished processing 2018-01-10 10:00:00 3 hr time horizon... +2026-04-29 09:22:18,627 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:18,775 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 7 hr time horizon... +2026-04-29 09:22:18,799 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:19,141 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 17 hr time horizon... +2026-04-29 09:22:19,161 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:19,604 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 14 hr time horizon... +2026-04-29 09:22:19,624 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:21,395 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 5 hr time horizon... +2026-04-29 09:22:21,414 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:22,211 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 8 hr time horizon... +2026-04-29 09:22:22,231 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:26,033 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 13 hr time horizon... +2026-04-29 09:22:26,057 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:26,525 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 1 hr time horizon... +2026-04-29 09:22:26,550 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:26,647 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 5 hr time horizon... +2026-04-29 09:22:26,665 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:27,154 - __main__ - INFO - Finished processing 2018-01-08 21:00:00 15 hr time horizon... +2026-04-29 09:22:27,185 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:27,574 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 14 hr time horizon... +2026-04-29 09:22:27,594 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:27,784 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 3 hr time horizon... +2026-04-29 09:22:27,803 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:28,491 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 9 hr time horizon... +2026-04-29 09:22:28,515 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:29,640 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:29,662 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:31,672 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:22:31,692 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:32,003 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:32,036 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:32,299 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:32,321 - __main__ - INFO - Processing values: 2018-01-03 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:32,617 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 2 hr time horizon... +2026-04-29 09:22:32,637 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 17 hr time horizon... +2026-04-29 09:22:32,908 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 13 hr time horizon... +2026-04-29 09:22:32,931 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 11 hr time horizon... +2026-04-29 09:22:33,140 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:33,165 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:35,786 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 11 hr time horizon... +2026-04-29 09:22:35,810 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:37,368 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:37,392 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:38,480 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 8 hr time horizon... +2026-04-29 09:22:38,504 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:39,449 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 4 hr time horizon... +2026-04-29 09:22:39,479 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:40,287 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:40,323 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:40,922 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 3 hr time horizon... +2026-04-29 09:22:40,949 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:40,967 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 8 hr time horizon... +2026-04-29 09:22:40,992 - __main__ - INFO - Processing values: 2018-01-03 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:41,153 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 7 hr time horizon... +2026-04-29 09:22:41,172 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:41,351 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 4 hr time horizon... +2026-04-29 09:22:41,373 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:41,881 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 1 hr time horizon... +2026-04-29 09:22:41,899 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:43,763 - __main__ - INFO - Finished processing 2018-01-01 23:00:00 11 hr time horizon... +2026-04-29 09:22:43,782 - __main__ - INFO - Processing values: 2018-01-27 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:46,349 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 3 hr time horizon... +2026-04-29 09:22:46,374 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:46,967 - __main__ - INFO - Finished processing 2018-01-03 06:00:00 12 hr time horizon... +2026-04-29 09:22:46,994 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:47,067 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 17 hr time horizon... +2026-04-29 09:22:47,088 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:47,322 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 15 hr time horizon... +2026-04-29 09:22:47,343 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:47,624 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 11 hr time horizon... +2026-04-29 09:22:47,643 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:48,134 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 8 hr time horizon... +2026-04-29 09:22:48,154 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:49,969 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 14 hr time horizon... +2026-04-29 09:22:49,991 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:51,060 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 16 hr time horizon... +2026-04-29 09:22:51,083 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:52,873 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 15 hr time horizon... +2026-04-29 09:22:52,898 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:55,118 - __main__ - INFO - Finished processing 2018-01-03 10:00:00 18 hr time horizon... +2026-04-29 09:22:55,140 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:55,233 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 13 hr time horizon... +2026-04-29 09:22:55,258 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:55,691 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 7 hr time horizon... +2026-04-29 09:22:55,721 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:55,935 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 16 hr time horizon... +2026-04-29 09:22:55,957 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:56,196 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 11 hr time horizon... +2026-04-29 09:22:56,225 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:56,835 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 17 hr time horizon... +2026-04-29 09:22:56,857 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:57,849 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 2 hr time horizon... +2026-04-29 09:22:57,871 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:58,392 - __main__ - INFO - Finished processing 2018-01-27 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:22:58,417 - __main__ - INFO - Processing values: 2018-01-15 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:01,139 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 12 hr time horizon... +2026-04-29 09:23:01,163 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:01,350 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 9 hr time horizon... +2026-04-29 09:23:01,375 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 2 hr time horizon... +2026-04-29 09:23:01,394 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 2 hr time horizon... +2026-04-29 09:23:01,415 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:01,781 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 16 hr time horizon... +2026-04-29 09:23:01,802 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 17 hr time horizon... +2026-04-29 09:23:01,905 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 7 hr time horizon... +2026-04-29 09:23:01,925 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:04,473 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 18 hr time horizon... +2026-04-29 09:23:04,498 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:05,376 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:05,397 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:05,885 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 10 hr time horizon... +2026-04-29 09:23:05,904 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:07,803 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:07,830 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:08,496 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 1 hr time horizon... +2026-04-29 09:23:08,517 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:09,265 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 13 hr time horizon... +2026-04-29 09:23:09,290 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:09,586 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 1 hr time horizon... +2026-04-29 09:23:09,606 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:09,815 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 4 hr time horizon... +2026-04-29 09:23:09,839 - __main__ - INFO - Processing values: 2018-01-13 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:10,050 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 16 hr time horizon... +2026-04-29 09:23:10,073 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:10,272 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 16 hr time horizon... +2026-04-29 09:23:10,291 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:10,802 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 18 hr time horizon... +2026-04-29 09:23:10,824 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:13,354 - __main__ - INFO - Finished processing 2018-01-15 16:00:00 4 hr time horizon... +2026-04-29 09:23:13,379 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:14,671 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 2 hr time horizon... +2026-04-29 09:23:14,692 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:14,780 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:14,802 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:14,910 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 4 hr time horizon... +2026-04-29 09:23:14,930 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:15,357 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 17 hr time horizon... +2026-04-29 09:23:15,377 - __main__ - INFO - Processing values: 2018-01-09 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:15,526 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:15,549 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:16,828 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 18 hr time horizon... +2026-04-29 09:23:16,850 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:17,675 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:17,698 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:19,914 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 16 hr time horizon... +2026-04-29 09:23:19,943 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:20,453 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 9 hr time horizon... +2026-04-29 09:23:20,482 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:20,686 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:20,714 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:22,988 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 16 hr time horizon... +2026-04-29 09:23:23,010 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:23,055 - __main__ - INFO - Finished processing 2018-01-13 09:00:00 15 hr time horizon... +2026-04-29 09:23:23,071 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:23,124 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 7 hr time horizon... +2026-04-29 09:23:23,145 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:23,558 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 2 hr time horizon... +2026-04-29 09:23:23,581 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:23,651 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 4 hr time horizon... +2026-04-29 09:23:23,670 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:24,205 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 14 hr time horizon... +2026-04-29 09:23:24,223 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:24,664 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 14 hr time horizon... +2026-04-29 09:23:24,687 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:26,936 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 12 hr time horizon... +2026-04-29 09:23:26,969 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:27,934 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 15 hr time horizon... +2026-04-29 09:23:27,959 - __main__ - INFO - Processing values: 2018-01-21 23:00:00 2 hr time horizon... +2026-04-29 09:23:27,988 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 10 hr time horizon... +2026-04-29 09:23:28,008 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:28,818 - __main__ - INFO - Finished processing 2018-01-09 16:00:00 1 hr time horizon... +2026-04-29 09:23:28,840 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:29,354 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 13 hr time horizon... +2026-04-29 09:23:29,382 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:30,958 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 4 hr time horizon... +2026-04-29 09:23:30,980 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:32,374 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:32,400 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:33,781 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 18 hr time horizon... +2026-04-29 09:23:33,806 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:34,033 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 6 hr time horizon... +2026-04-29 09:23:34,053 - __main__ - INFO - Processing values: 2018-01-04 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:34,483 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 6 hr time horizon... +2026-04-29 09:23:34,503 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:34,761 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 4 hr time horizon... +2026-04-29 09:23:34,784 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 7 hr time horizon... +2026-04-29 09:23:35,015 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 17 hr time horizon... +2026-04-29 09:23:35,040 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:37,635 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 3 hr time horizon... +2026-04-29 09:23:37,656 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:38,084 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 6 hr time horizon... +2026-04-29 09:23:38,105 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 16 hr time horizon... +2026-04-29 09:23:38,210 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 10 hr time horizon... +2026-04-29 09:23:38,233 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:40,299 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:40,319 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:40,622 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 11 hr time horizon... +2026-04-29 09:23:40,645 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:41,447 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:41,469 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:42,414 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 5 hr time horizon... +2026-04-29 09:23:42,438 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:43,394 - __main__ - INFO - Finished processing 2018-01-21 23:00:00 2 hr time horizon... +2026-04-29 09:23:43,397 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:43,426 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 4 hr time horizon... +2026-04-29 09:23:43,430 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:44,603 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 8 hr time horizon... +2026-04-29 09:23:44,632 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:44,743 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 7 hr time horizon... +2026-04-29 09:23:44,763 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 2 hr time horizon... +2026-04-29 09:23:44,790 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 18 hr time horizon... +2026-04-29 09:23:44,814 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:47,220 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 17 hr time horizon... +2026-04-29 09:23:47,246 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:48,634 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 12 hr time horizon... +2026-04-29 09:23:48,661 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:49,722 - __main__ - INFO - Finished processing 2018-01-14 21:00:00 17 hr time horizon... +2026-04-29 09:23:49,745 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:49,988 - __main__ - INFO - Finished processing 2018-01-04 01:00:00 11 hr time horizon... +2026-04-29 09:23:50,009 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:50,270 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 3 hr time horizon... +2026-04-29 09:23:50,293 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:51,233 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 7 hr time horizon... +2026-04-29 09:23:51,254 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 13 hr time horizon... +2026-04-29 09:23:51,271 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 18 hr time horizon... +2026-04-29 09:23:51,293 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:53,657 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 8 hr time horizon... +2026-04-29 09:23:53,680 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:54,190 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 16 hr time horizon... +2026-04-29 09:23:54,212 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:55,220 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 1 hr time horizon... +2026-04-29 09:23:55,245 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:56,094 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 9 hr time horizon... +2026-04-29 09:23:56,117 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:56,712 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 3 hr time horizon... +2026-04-29 09:23:56,740 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:56,933 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:56,956 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:57,827 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 4 hr time horizon... +2026-04-29 09:23:57,857 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:59,743 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:23:59,766 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:00,089 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 4 hr time horizon... +2026-04-29 09:24:00,111 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 13 hr time horizon... +2026-04-29 09:24:00,307 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 14 hr time horizon... +2026-04-29 09:24:00,330 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 13 hr time horizon... +2026-04-29 09:24:00,375 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 6 hr time horizon... +2026-04-29 09:24:00,399 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 7 hr time horizon... +2026-04-29 09:24:00,522 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 2 hr time horizon... +2026-04-29 09:24:00,543 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:03,689 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 14 hr time horizon... +2026-04-29 09:24:03,711 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:04,277 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 11 hr time horizon... +2026-04-29 09:24:04,300 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 15 hr time horizon... +2026-04-29 09:24:04,312 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 3 hr time horizon... +2026-04-29 09:24:04,344 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:05,381 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 15 hr time horizon... +2026-04-29 09:24:05,404 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:06,450 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 8 hr time horizon... +2026-04-29 09:24:06,474 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:06,678 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 13 hr time horizon... +2026-04-29 09:24:06,703 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:08,667 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 6 hr time horizon... +2026-04-29 09:24:08,686 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:09,130 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 18 hr time horizon... +2026-04-29 09:24:09,160 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:09,558 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 13 hr time horizon... +2026-04-29 09:24:09,580 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:10,950 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 14 hr time horizon... +2026-04-29 09:24:10,976 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:11,576 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 9 hr time horizon... +2026-04-29 09:24:11,597 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:12,407 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 1 hr time horizon... +2026-04-29 09:24:12,427 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:12,902 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 11 hr time horizon... +2026-04-29 09:24:12,931 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 4 hr time horizon... +2026-04-29 09:24:12,999 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 10 hr time horizon... +2026-04-29 09:24:13,026 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:15,264 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 5 hr time horizon... +2026-04-29 09:24:15,287 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:15,485 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 1 hr time horizon... +2026-04-29 09:24:15,508 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:15,990 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 13 hr time horizon... +2026-04-29 09:24:16,013 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 17 hr time horizon... +2026-04-29 09:24:16,086 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 7 hr time horizon... +2026-04-29 09:24:16,107 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:18,461 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 13 hr time horizon... +2026-04-29 09:24:18,486 - __main__ - INFO - Processing values: 2018-01-01 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:19,634 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 10 hr time horizon... +2026-04-29 09:24:19,664 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:19,780 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:19,805 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:19,971 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 15 hr time horizon... +2026-04-29 09:24:19,992 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:21,401 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 16 hr time horizon... +2026-04-29 09:24:21,424 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 2 hr time horizon... +2026-04-29 09:24:21,646 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 13 hr time horizon... +2026-04-29 09:24:21,676 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:22,612 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 7 hr time horizon... +2026-04-29 09:24:22,639 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:24,659 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:24,685 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:25,323 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:25,348 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:26,666 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 5 hr time horizon... +2026-04-29 09:24:26,688 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:27,189 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 2 hr time horizon... +2026-04-29 09:24:27,209 - __main__ - INFO - Processing values: 2018-01-21 10:00:00 2 hr time horizon... +2026-04-29 09:24:27,241 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 13 hr time horizon... +2026-04-29 09:24:27,261 - __main__ - INFO - Processing values: 2018-01-24 12:00:00 18 hr time horizon... +2026-04-29 09:24:27,430 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:27,454 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:28,850 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 13 hr time horizon... +2026-04-29 09:24:28,872 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:31,070 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 4 hr time horizon... +2026-04-29 09:24:31,094 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 1 hr time horizon... +2026-04-29 09:24:31,195 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 6 hr time horizon... +2026-04-29 09:24:31,218 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:31,274 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 17 hr time horizon... +2026-04-29 09:24:31,297 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 6 hr time horizon... +2026-04-29 09:24:31,305 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 3 hr time horizon... +2026-04-29 09:24:31,328 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:32,612 - __main__ - INFO - Finished processing 2018-01-01 04:00:00 5 hr time horizon... +2026-04-29 09:24:32,638 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:35,120 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 17 hr time horizon... +2026-04-29 09:24:35,143 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:35,242 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 6 hr time horizon... +2026-04-29 09:24:35,264 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 9 hr time horizon... +2026-04-29 09:24:35,418 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:35,451 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:35,503 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 18 hr time horizon... +2026-04-29 09:24:35,527 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:36,393 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 2 hr time horizon... +2026-04-29 09:24:36,414 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:38,107 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 15 hr time horizon... +2026-04-29 09:24:38,130 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:38,288 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 4 hr time horizon... +2026-04-29 09:24:38,311 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:41,321 - __main__ - INFO - Finished processing 2018-01-24 12:00:00 18 hr time horizon... +2026-04-29 09:24:41,351 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:41,492 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 14 hr time horizon... +2026-04-29 09:24:41,519 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 10 hr time horizon... +2026-04-29 09:24:41,605 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:41,627 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:41,780 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 16 hr time horizon... +2026-04-29 09:24:41,800 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:42,763 - __main__ - INFO - Finished processing 2018-01-21 10:00:00 2 hr time horizon... +2026-04-29 09:24:42,787 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:43,013 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 13 hr time horizon... +2026-04-29 09:24:43,035 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:44,572 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 15 hr time horizon... +2026-04-29 09:24:44,595 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:46,288 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:46,308 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:46,734 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 6 hr time horizon... +2026-04-29 09:24:46,759 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:47,257 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 4 hr time horizon... +2026-04-29 09:24:47,278 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 14 hr time horizon... +2026-04-29 09:24:47,309 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 11 hr time horizon... +2026-04-29 09:24:47,335 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:48,427 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 15 hr time horizon... +2026-04-29 09:24:48,448 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:50,640 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 9 hr time horizon... +2026-04-29 09:24:50,664 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 9 hr time horizon... +2026-04-29 09:24:50,714 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 13 hr time horizon... +2026-04-29 09:24:50,740 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:50,964 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:50,998 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 10 hr time horizon... +2026-04-29 09:24:51,036 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 8 hr time horizon... +2026-04-29 09:24:51,059 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:52,356 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:52,378 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:53,346 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 9 hr time horizon... +2026-04-29 09:24:53,367 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:53,924 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 5 hr time horizon... +2026-04-29 09:24:53,947 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:56,340 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:56,364 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:56,519 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 2 hr time horizon... +2026-04-29 09:24:56,539 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:57,516 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 1 hr time horizon... +2026-04-29 09:24:57,538 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:57,673 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:57,698 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:58,092 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 11 hr time horizon... +2026-04-29 09:24:58,117 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:58,596 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 3 hr time horizon... +2026-04-29 09:24:58,619 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:59,755 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:24:59,777 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:01,940 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 2 hr time horizon... +2026-04-29 09:25:01,964 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:02,647 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 14 hr time horizon... +2026-04-29 09:25:02,671 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:03,457 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 17 hr time horizon... +2026-04-29 09:25:03,484 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:03,619 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 11 hr time horizon... +2026-04-29 09:25:03,643 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 1 hr time horizon... +2026-04-29 09:25:03,730 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 7 hr time horizon... +2026-04-29 09:25:03,754 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:05,853 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 5 hr time horizon... +2026-04-29 09:25:05,879 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:06,841 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:06,868 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 4 hr time horizon... +2026-04-29 09:25:06,876 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 9 hr time horizon... +2026-04-29 09:25:06,900 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:07,045 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 10 hr time horizon... +2026-04-29 09:25:07,067 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:07,899 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 18 hr time horizon... +2026-04-29 09:25:07,924 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:08,768 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 9 hr time horizon... +2026-04-29 09:25:08,791 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:09,875 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 8 hr time horizon... +2026-04-29 09:25:09,896 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:10,466 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:10,497 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:11,416 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 8 hr time horizon... +2026-04-29 09:25:11,440 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:12,764 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 14 hr time horizon... +2026-04-29 09:25:12,788 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:13,651 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 2 hr time horizon... +2026-04-29 09:25:13,673 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:13,826 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 18 hr time horizon... +2026-04-29 09:25:13,850 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:14,927 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 12 hr time horizon... +2026-04-29 09:25:14,949 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:15,655 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:15,684 - __main__ - INFO - Processing values: 2018-01-26 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:17,756 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:17,788 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:18,265 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 8 hr time horizon... +2026-04-29 09:25:18,293 - __main__ - INFO - Processing values: 2018-01-25 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:18,440 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 1 hr time horizon... +2026-04-29 09:25:18,443 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 1 hr time horizon... +2026-04-29 09:25:18,460 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 9 hr time horizon... +2026-04-29 09:25:18,463 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:20,230 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:20,252 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 2 hr time horizon... +2026-04-29 09:25:20,345 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 5 hr time horizon... +2026-04-29 09:25:20,370 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:21,424 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:21,443 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:21,937 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 1 hr time horizon... +2026-04-29 09:25:21,955 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:22,131 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 18 hr time horizon... +2026-04-29 09:25:22,153 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:22,937 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 4 hr time horizon... +2026-04-29 09:25:22,962 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:24,166 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 16 hr time horizon... +2026-04-29 09:25:24,191 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:25,767 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 9 hr time horizon... +2026-04-29 09:25:25,788 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 3 hr time horizon... +2026-04-29 09:25:26,050 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 15 hr time horizon... +2026-04-29 09:25:26,069 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:32,297 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 2 hr time horizon... +2026-04-29 09:25:32,312 - __main__ - INFO - Processing values: 2018-01-24 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:33,209 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 15 hr time horizon... +2026-04-29 09:25:33,233 - __main__ - INFO - Processing values: 2018-01-02 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:34,182 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 5 hr time horizon... +2026-04-29 09:25:34,199 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:35,237 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 14 hr time horizon... +2026-04-29 09:25:35,255 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:35,397 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 17 hr time horizon... +2026-04-29 09:25:35,414 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:35,761 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 12 hr time horizon... +2026-04-29 09:25:35,782 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:36,604 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 2 hr time horizon... +2026-04-29 09:25:36,620 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:36,907 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 5 hr time horizon... +2026-04-29 09:25:36,927 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:38,556 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 3 hr time horizon... +2026-04-29 09:25:38,577 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:45,310 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 11 hr time horizon... +2026-04-29 09:25:45,328 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:45,421 - __main__ - INFO - Finished processing 2018-01-24 20:00:00 2 hr time horizon... +2026-04-29 09:25:45,436 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:45,857 - __main__ - INFO - Finished processing 2018-01-02 20:00:00 9 hr time horizon... +2026-04-29 09:25:45,873 - __main__ - INFO - Processing values: 2018-01-02 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:47,370 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 9 hr time horizon... +2026-04-29 09:25:47,392 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:47,609 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 11 hr time horizon... +2026-04-29 09:25:47,628 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:47,780 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 15 hr time horizon... +2026-04-29 09:25:47,800 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:49,450 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 1 hr time horizon... +2026-04-29 09:25:49,468 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:49,557 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 8 hr time horizon... +2026-04-29 09:25:49,564 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 12 hr time horizon... +2026-04-29 09:25:49,581 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 2 hr time horizon... +2026-04-29 09:25:49,592 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 13 hr time horizon... +2026-04-29 09:25:49,763 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 18 hr time horizon... +2026-04-29 09:25:49,787 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:51,616 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 5 hr time horizon... +2026-04-29 09:25:51,637 - __main__ - INFO - Processing values: 2018-01-11 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:56,327 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 9 hr time horizon... +2026-04-29 09:25:56,344 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:57,694 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 2 hr time horizon... +2026-04-29 09:25:57,715 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:58,144 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 14 hr time horizon... +2026-04-29 09:25:58,165 - __main__ - INFO - Processing values: 2018-01-17 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:25:59,986 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 5 hr time horizon... +2026-04-29 09:26:00,004 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:00,480 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 5 hr time horizon... +2026-04-29 09:26:00,502 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:01,554 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 4 hr time horizon... +2026-04-29 09:26:01,572 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:02,371 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:02,392 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 7 hr time horizon... +2026-04-29 09:26:02,441 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 3 hr time horizon... +2026-04-29 09:26:02,462 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:03,926 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:03,948 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:05,427 - __main__ - INFO - Finished processing 2018-01-11 13:00:00 15 hr time horizon... +2026-04-29 09:26:05,447 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:05,974 - __main__ - INFO - Finished processing 2018-01-02 09:00:00 16 hr time horizon... +2026-04-29 09:26:05,992 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:06,464 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 17 hr time horizon... +2026-04-29 09:26:06,484 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:09,102 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:09,126 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:10,736 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 6 hr time horizon... +2026-04-29 09:26:10,765 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:11,177 - __main__ - INFO - Finished processing 2018-01-17 12:00:00 5 hr time horizon... +2026-04-29 09:26:11,196 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:12,237 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 2 hr time horizon... +2026-04-29 09:26:12,256 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:12,630 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 12 hr time horizon... +2026-04-29 09:26:12,649 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:13,408 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 5 hr time horizon... +2026-04-29 09:26:13,427 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:15,315 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 7 hr time horizon... +2026-04-29 09:26:15,338 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:15,991 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:16,023 - __main__ - INFO - Processing values: 2018-01-07 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:16,583 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:16,608 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:18,225 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 15 hr time horizon... +2026-04-29 09:26:18,253 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:18,488 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 12 hr time horizon... +2026-04-29 09:26:18,526 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:18,825 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 2 hr time horizon... +2026-04-29 09:26:18,848 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:19,637 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 8 hr time horizon... +2026-04-29 09:26:19,655 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:22,126 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 12 hr time horizon... +2026-04-29 09:26:22,148 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:22,987 - __main__ - INFO - Finished processing 2018-01-25 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:23,013 - __main__ - INFO - Processing values: 2018-01-21 11:00:00 9 hr time horizon... +2026-04-29 09:26:23,036 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 11 hr time horizon... +2026-04-29 09:26:23,060 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:23,946 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 8 hr time horizon... +2026-04-29 09:26:23,966 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:24,549 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:24,569 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:25,795 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 13 hr time horizon... +2026-04-29 09:26:25,815 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:26,211 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 15 hr time horizon... +2026-04-29 09:26:26,234 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:26,708 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 9 hr time horizon... +2026-04-29 09:26:26,728 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:27,441 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:27,462 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:28,251 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 4 hr time horizon... +2026-04-29 09:26:28,272 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:30,331 - __main__ - INFO - Finished processing 2018-01-07 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:30,358 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:31,673 - __main__ - INFO - Finished processing 2018-01-26 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:31,698 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:32,045 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 6 hr time horizon... +2026-04-29 09:26:32,065 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:32,205 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 6 hr time horizon... +2026-04-29 09:26:32,231 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:32,353 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 4 hr time horizon... +2026-04-29 09:26:32,376 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:32,881 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 15 hr time horizon... +2026-04-29 09:26:32,902 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 3 hr time horizon... +2026-04-29 09:26:33,049 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 13 hr time horizon... +2026-04-29 09:26:33,071 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 15 hr time horizon... +2026-04-29 09:26:33,101 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 17 hr time horizon... +2026-04-29 09:26:33,123 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:36,186 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 17 hr time horizon... +2026-04-29 09:26:36,213 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:36,831 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 16 hr time horizon... +2026-04-29 09:26:36,854 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:37,028 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 5 hr time horizon... +2026-04-29 09:26:37,051 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:37,216 - __main__ - INFO - Finished processing 2018-01-21 11:00:00 9 hr time horizon... +2026-04-29 09:26:37,236 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:38,296 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 12 hr time horizon... +2026-04-29 09:26:38,326 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:38,810 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 14 hr time horizon... +2026-04-29 09:26:38,830 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:40,521 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 1 hr time horizon... +2026-04-29 09:26:40,540 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:40,677 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 7 hr time horizon... +2026-04-29 09:26:40,698 - __main__ - INFO - Processing values: 2018-01-24 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:41,219 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 7 hr time horizon... +2026-04-29 09:26:41,243 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:42,533 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 12 hr time horizon... +2026-04-29 09:26:42,556 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:43,709 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 18 hr time horizon... +2026-04-29 09:26:43,733 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:45,137 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 7 hr time horizon... +2026-04-29 09:26:45,158 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:45,322 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 1 hr time horizon... +2026-04-29 09:26:45,346 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:46,688 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 4 hr time horizon... +2026-04-29 09:26:46,712 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:46,818 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 17 hr time horizon... +2026-04-29 09:26:46,843 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:46,940 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 6 hr time horizon... +2026-04-29 09:26:46,962 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:47,631 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 3 hr time horizon... +2026-04-29 09:26:47,651 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:48,077 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 15 hr time horizon... +2026-04-29 09:26:48,101 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 6 hr time horizon... +2026-04-29 09:26:48,175 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 12 hr time horizon... +2026-04-29 09:26:48,198 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:50,285 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 3 hr time horizon... +2026-04-29 09:26:50,304 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:51,654 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 1 hr time horizon... +2026-04-29 09:26:51,675 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:52,368 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 6 hr time horizon... +2026-04-29 09:26:52,392 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:53,695 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 4 hr time horizon... +2026-04-29 09:26:53,718 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:54,207 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 1 hr time horizon... +2026-04-29 09:26:54,227 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:55,301 - __main__ - INFO - Finished processing 2018-01-24 12:00:00 14 hr time horizon... +2026-04-29 09:26:55,321 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:55,503 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 16 hr time horizon... +2026-04-29 09:26:55,525 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:56,490 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 4 hr time horizon... +2026-04-29 09:26:56,514 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 13 hr time horizon... +2026-04-29 09:26:56,605 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 13 hr time horizon... +2026-04-29 09:26:56,629 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:59,018 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 15 hr time horizon... +2026-04-29 09:26:59,044 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:26:59,903 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:26:59,931 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:00,020 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 5 hr time horizon... +2026-04-29 09:27:00,042 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:00,806 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 6 hr time horizon... +2026-04-29 09:27:00,826 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:01,354 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 1 hr time horizon... +2026-04-29 09:27:01,376 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:02,895 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 10 hr time horizon... +2026-04-29 09:27:02,922 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:02,979 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 6 hr time horizon... +2026-04-29 09:27:03,002 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:03,552 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 13 hr time horizon... +2026-04-29 09:27:03,574 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:04,255 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 8 hr time horizon... +2026-04-29 09:27:04,281 - __main__ - INFO - Processing values: 2018-01-30 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:04,342 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 9 hr time horizon... +2026-04-29 09:27:04,365 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:06,008 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 9 hr time horizon... +2026-04-29 09:27:06,032 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:06,964 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 2 hr time horizon... +2026-04-29 09:27:06,985 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 1 hr time horizon... +2026-04-29 09:27:07,208 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 13 hr time horizon... +2026-04-29 09:27:07,238 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:08,217 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 2 hr time horizon... +2026-04-29 09:27:08,238 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 16 hr time horizon... +2026-04-29 09:27:08,252 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 10 hr time horizon... +2026-04-29 09:27:08,280 - __main__ - INFO - Processing values: 2018-01-25 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:11,184 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 18 hr time horizon... +2026-04-29 09:27:11,205 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:11,747 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 13 hr time horizon... +2026-04-29 09:27:11,767 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:12,051 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 13 hr time horizon... +2026-04-29 09:27:12,076 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:13,624 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 5 hr time horizon... +2026-04-29 09:27:13,645 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:14,218 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 8 hr time horizon... +2026-04-29 09:27:14,237 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:15,126 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:15,150 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:16,569 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 7 hr time horizon... +2026-04-29 09:27:16,578 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 18 hr time horizon... +2026-04-29 09:27:16,595 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:16,605 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 3 hr time horizon... +2026-04-29 09:27:16,652 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 13 hr time horizon... +2026-04-29 09:27:16,673 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 9 hr time horizon... +2026-04-29 09:27:16,720 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 5 hr time horizon... +2026-04-29 09:27:16,741 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:17,934 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 14 hr time horizon... +2026-04-29 09:27:17,954 - __main__ - INFO - Processing values: 2018-01-10 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:18,252 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 6 hr time horizon... +2026-04-29 09:27:18,273 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:19,394 - __main__ - INFO - Finished processing 2018-01-30 05:00:00 6 hr time horizon... +2026-04-29 09:27:19,414 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 13 hr time horizon... +2026-04-29 09:27:19,615 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 10 hr time horizon... +2026-04-29 09:27:19,636 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 4 hr time horizon... +2026-04-29 09:27:19,736 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 4 hr time horizon... +2026-04-29 09:27:19,754 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:22,797 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 1 hr time horizon... +2026-04-29 09:27:22,814 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:28,465 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 5 hr time horizon... +2026-04-29 09:27:28,480 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:32,641 - __main__ - INFO - Finished processing 2018-01-10 10:00:00 16 hr time horizon... +2026-04-29 09:27:32,660 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:32,927 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 16 hr time horizon... +2026-04-29 09:27:32,944 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:33,631 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 4 hr time horizon... +2026-04-29 09:27:33,648 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:35,758 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 6 hr time horizon... +2026-04-29 09:27:35,781 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:39,878 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 3 hr time horizon... +2026-04-29 09:27:39,895 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:41,760 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 12 hr time horizon... +2026-04-29 09:27:41,776 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:42,922 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 15 hr time horizon... +2026-04-29 09:27:42,939 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:43,836 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 2 hr time horizon... +2026-04-29 09:27:43,857 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:45,503 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 17 hr time horizon... +2026-04-29 09:27:45,520 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 11 hr time horizon... +2026-04-29 09:27:45,539 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 8 hr time horizon... +2026-04-29 09:27:45,558 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:46,227 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 13 hr time horizon... +2026-04-29 09:27:46,244 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 4 hr time horizon... +2026-04-29 09:27:46,729 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 11 hr time horizon... +2026-04-29 09:27:46,752 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:50,118 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 8 hr time horizon... +2026-04-29 09:27:50,137 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:53,750 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 12 hr time horizon... +2026-04-29 09:27:53,771 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 4 hr time horizon... +2026-04-29 09:27:53,801 - __main__ - INFO - Finished processing 2018-01-25 05:00:00 10 hr time horizon... +2026-04-29 09:27:53,819 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:54,005 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 3 hr time horizon... +2026-04-29 09:27:54,024 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:54,683 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 18 hr time horizon... +2026-04-29 09:27:54,703 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 6 hr time horizon... +2026-04-29 09:27:54,765 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 9 hr time horizon... +2026-04-29 09:27:54,782 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:54,946 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 13 hr time horizon... +2026-04-29 09:27:54,964 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:57,089 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 2 hr time horizon... +2026-04-29 09:27:57,115 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:58,096 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 2 hr time horizon... +2026-04-29 09:27:58,118 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:58,237 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 9 hr time horizon... +2026-04-29 09:27:58,258 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:58,593 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 18 hr time horizon... +2026-04-29 09:27:58,614 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:59,011 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 9 hr time horizon... +2026-04-29 09:27:59,031 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:27:59,565 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 8 hr time horizon... +2026-04-29 09:27:59,584 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:00,247 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 4 hr time horizon... +2026-04-29 09:28:00,265 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:01,028 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 12 hr time horizon... +2026-04-29 09:28:01,048 - __main__ - INFO - Processing values: 2018-01-07 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:02,191 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 11 hr time horizon... +2026-04-29 09:28:02,211 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:03,439 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 15 hr time horizon... +2026-04-29 09:28:03,461 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:07,086 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:07,116 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:08,267 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 9 hr time horizon... +2026-04-29 09:28:08,288 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 11 hr time horizon... +2026-04-29 09:28:08,311 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 6 hr time horizon... +2026-04-29 09:28:08,333 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:08,428 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 17 hr time horizon... +2026-04-29 09:28:08,453 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:08,560 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 9 hr time horizon... +2026-04-29 09:28:08,583 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:08,922 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 11 hr time horizon... +2026-04-29 09:28:08,942 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:09,205 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 6 hr time horizon... +2026-04-29 09:28:09,225 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:10,112 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 8 hr time horizon... +2026-04-29 09:28:10,135 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:11,730 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 7 hr time horizon... +2026-04-29 09:28:11,754 - __main__ - INFO - Processing values: 2018-01-02 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:11,802 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 15 hr time horizon... +2026-04-29 09:28:11,825 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:12,454 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 13 hr time horizon... +2026-04-29 09:28:12,477 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:13,363 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:13,386 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:13,489 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 3 hr time horizon... +2026-04-29 09:28:13,517 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:14,311 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 7 hr time horizon... +2026-04-29 09:28:14,334 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:14,740 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 14 hr time horizon... +2026-04-29 09:28:14,761 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:15,649 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 4 hr time horizon... +2026-04-29 09:28:15,674 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:15,750 - __main__ - INFO - Finished processing 2018-01-07 13:00:00 11 hr time horizon... +2026-04-29 09:28:15,773 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:16,302 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 14 hr time horizon... +2026-04-29 09:28:16,321 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:18,155 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 14 hr time horizon... +2026-04-29 09:28:18,177 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:21,569 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 15 hr time horizon... +2026-04-29 09:28:21,593 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:21,785 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 11 hr time horizon... +2026-04-29 09:28:21,806 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:22,886 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 15 hr time horizon... +2026-04-29 09:28:22,906 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:23,177 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 13 hr time horizon... +2026-04-29 09:28:23,200 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:23,570 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 13 hr time horizon... +2026-04-29 09:28:23,578 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 12 hr time horizon... +2026-04-29 09:28:23,593 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 7 hr time horizon... +2026-04-29 09:28:23,603 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:23,789 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 6 hr time horizon... +2026-04-29 09:28:23,810 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:24,121 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:24,145 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:26,564 - __main__ - INFO - Finished processing 2018-01-02 12:00:00 14 hr time horizon... +2026-04-29 09:28:26,586 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:27,505 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 7 hr time horizon... +2026-04-29 09:28:27,526 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:28,299 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:28,322 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:28,609 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 5 hr time horizon... +2026-04-29 09:28:28,628 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:28,700 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 10 hr time horizon... +2026-04-29 09:28:28,723 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:28,872 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 8 hr time horizon... +2026-04-29 09:28:28,891 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:29,160 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 13 hr time horizon... +2026-04-29 09:28:29,180 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:30,447 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 15 hr time horizon... +2026-04-29 09:28:30,469 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:30,566 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 18 hr time horizon... +2026-04-29 09:28:30,592 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:32,901 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 15 hr time horizon... +2026-04-29 09:28:32,920 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:36,325 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 3 hr time horizon... +2026-04-29 09:28:36,347 - __main__ - INFO - Processing values: 2018-01-26 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:36,513 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 2 hr time horizon... +2026-04-29 09:28:36,544 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:37,088 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 9 hr time horizon... +2026-04-29 09:28:37,112 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 6 hr time horizon... +2026-04-29 09:28:37,112 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:37,135 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:38,340 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 11 hr time horizon... +2026-04-29 09:28:38,361 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:38,443 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 7 hr time horizon... +2026-04-29 09:28:38,465 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 17 hr time horizon... +2026-04-29 09:28:38,491 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 18 hr time horizon... +2026-04-29 09:28:38,511 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:28:39,596 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:39,623 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:40,592 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 11 hr time horizon... +2026-04-29 09:28:40,620 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:41,611 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:41,634 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:41,878 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 8 hr time horizon... +2026-04-29 09:28:41,897 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:42,365 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 7 hr time horizon... +2026-04-29 09:28:42,393 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:42,480 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 8 hr time horizon... +2026-04-29 09:28:42,502 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:43,439 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 15 hr time horizon... +2026-04-29 09:28:43,472 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:43,807 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 4 hr time horizon... +2026-04-29 09:28:43,841 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:44,332 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 11 hr time horizon... +2026-04-29 09:28:44,352 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:44,809 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 18 hr time horizon... +2026-04-29 09:28:44,828 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:46,300 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 2 hr time horizon... +2026-04-29 09:28:46,315 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:50,000 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 8 hr time horizon... +2026-04-29 09:28:50,024 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 6 hr time horizon... +2026-04-29 09:28:50,089 - __main__ - INFO - Finished processing 2018-01-26 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:50,108 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:51,372 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 1 hr time horizon... +2026-04-29 09:28:51,392 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:52,403 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:52,426 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:52,884 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:52,910 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:53,010 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 18 hr time horizon... +2026-04-29 09:28:53,032 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 2 hr time horizon... +2026-04-29 09:28:53,145 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 18 hr time horizon... +2026-04-29 09:28:53,166 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:53,440 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 8 hr time horizon... +2026-04-29 09:28:53,458 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:54,396 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 18 hr time horizon... +2026-04-29 09:28:54,420 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:55,787 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 1 hr time horizon... +2026-04-29 09:28:55,806 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:55,835 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 8 hr time horizon... +2026-04-29 09:28:55,857 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:56,776 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:56,798 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:57,337 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 9 hr time horizon... +2026-04-29 09:28:57,362 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 18 hr time horizon... +2026-04-29 09:28:57,432 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:57,453 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:58,475 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:58,503 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:59,108 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 6 hr time horizon... +2026-04-29 09:28:59,134 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:59,671 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 2 hr time horizon... +2026-04-29 09:28:59,696 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:28:59,821 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 12 hr time horizon... +2026-04-29 09:28:59,844 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:01,042 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 15 hr time horizon... +2026-04-29 09:29:01,066 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:04,490 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 6 hr time horizon... +2026-04-29 09:29:04,511 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:05,265 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 5 hr time horizon... +2026-04-29 09:29:05,287 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:06,277 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 1 hr time horizon... +2026-04-29 09:29:06,297 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:08,165 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 17 hr time horizon... +2026-04-29 09:29:08,195 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:08,765 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 8 hr time horizon... +2026-04-29 09:29:08,787 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:08,915 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 2 hr time horizon... +2026-04-29 09:29:08,941 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:09,190 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 16 hr time horizon... +2026-04-29 09:29:09,219 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:10,348 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 2 hr time horizon... +2026-04-29 09:29:10,370 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:10,859 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 16 hr time horizon... +2026-04-29 09:29:10,883 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:11,314 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 1 hr time horizon... +2026-04-29 09:29:11,349 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:11,694 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 3 hr time horizon... +2026-04-29 09:29:11,717 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:12,197 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 10 hr time horizon... +2026-04-29 09:29:12,218 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:12,606 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:12,631 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:13,195 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 10 hr time horizon... +2026-04-29 09:29:13,220 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:13,421 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 5 hr time horizon... +2026-04-29 09:29:13,448 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:14,508 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 17 hr time horizon... +2026-04-29 09:29:14,530 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:15,433 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 15 hr time horizon... +2026-04-29 09:29:15,453 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 14 hr time horizon... +2026-04-29 09:29:15,589 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 4 hr time horizon... +2026-04-29 09:29:15,611 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:19,338 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 3 hr time horizon... +2026-04-29 09:29:19,358 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:19,994 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 6 hr time horizon... +2026-04-29 09:29:20,017 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:21,844 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 8 hr time horizon... +2026-04-29 09:29:21,870 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:22,873 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:22,895 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:24,014 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:24,039 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 17 hr time horizon... +2026-04-29 09:29:24,041 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 15 hr time horizon... +2026-04-29 09:29:24,065 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:24,926 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:24,958 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:24,972 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 5 hr time horizon... +2026-04-29 09:29:25,000 - __main__ - INFO - Processing values: 2018-01-20 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:25,463 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 15 hr time horizon... +2026-04-29 09:29:25,483 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:26,074 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 2 hr time horizon... +2026-04-29 09:29:26,099 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 1 hr time horizon... +2026-04-29 09:29:26,135 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:26,157 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:26,379 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 2 hr time horizon... +2026-04-29 09:29:26,397 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:26,945 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 10 hr time horizon... +2026-04-29 09:29:26,962 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:27,529 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 17 hr time horizon... +2026-04-29 09:29:27,555 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:28,090 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:28,117 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:28,811 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 2 hr time horizon... +2026-04-29 09:29:28,834 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:30,050 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 14 hr time horizon... +2026-04-29 09:29:30,072 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 4 hr time horizon... +2026-04-29 09:29:30,253 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 12 hr time horizon... +2026-04-29 09:29:30,277 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:30,938 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 9 hr time horizon... +2026-04-29 09:29:30,957 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:34,027 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 2 hr time horizon... +2026-04-29 09:29:34,047 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:35,082 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 3 hr time horizon... +2026-04-29 09:29:35,102 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:35,560 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 10 hr time horizon... +2026-04-29 09:29:35,582 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:38,278 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 17 hr time horizon... +2026-04-29 09:29:38,305 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:38,651 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 17 hr time horizon... +2026-04-29 09:29:38,672 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:38,853 - __main__ - INFO - Finished processing 2018-01-20 18:00:00 17 hr time horizon... +2026-04-29 09:29:38,878 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:38,987 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:39,014 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:39,103 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 12 hr time horizon... +2026-04-29 09:29:39,133 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:39,727 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:39,754 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:40,328 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:40,356 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:40,951 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:40,975 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:41,229 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 17 hr time horizon... +2026-04-29 09:29:41,256 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:29:42,442 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:42,476 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:42,558 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:42,582 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:43,310 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 18 hr time horizon... +2026-04-29 09:29:43,333 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 15 hr time horizon... +2026-04-29 09:29:43,463 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 17 hr time horizon... +2026-04-29 09:29:43,484 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:45,094 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 16 hr time horizon... +2026-04-29 09:29:45,117 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 16 hr time horizon... +2026-04-29 09:29:45,341 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 4 hr time horizon... +2026-04-29 09:29:45,360 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:46,375 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 12 hr time horizon... +2026-04-29 09:29:46,396 - __main__ - INFO - Processing values: 2018-01-26 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:49,315 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:49,337 - __main__ - INFO - Processing values: 2018-01-25 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:50,759 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 17 hr time horizon... +2026-04-29 09:29:50,780 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 5 hr time horizon... +2026-04-29 09:29:51,057 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 10 hr time horizon... +2026-04-29 09:29:51,089 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:54,230 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 13 hr time horizon... +2026-04-29 09:29:54,260 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:54,544 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:54,572 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:54,726 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 14 hr time horizon... +2026-04-29 09:29:54,749 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:55,181 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:55,205 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:55,321 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 3 hr time horizon... +2026-04-29 09:29:55,343 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:55,816 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 18 hr time horizon... +2026-04-29 09:29:55,838 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 4 hr time horizon... +2026-04-29 09:29:56,091 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 13 hr time horizon... +2026-04-29 09:29:56,122 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:56,225 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 1 hr time horizon... +2026-04-29 09:29:56,244 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:57,593 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 7 hr time horizon... +2026-04-29 09:29:57,614 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:57,889 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:57,916 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:29:59,396 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 15 hr time horizon... +2026-04-29 09:29:59,415 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 15 hr time horizon... +2026-04-29 09:29:59,418 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 16 hr time horizon... +2026-04-29 09:29:59,437 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:00,280 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 16 hr time horizon... +2026-04-29 09:30:00,300 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 18 hr time horizon... +2026-04-29 09:30:00,484 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:00,508 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:01,083 - __main__ - INFO - Finished processing 2018-01-26 15:00:00 18 hr time horizon... +2026-04-29 09:30:01,106 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:03,113 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 2 hr time horizon... +2026-04-29 09:30:03,142 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:05,384 - __main__ - INFO - Finished processing 2018-01-25 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:05,410 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:06,965 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 10 hr time horizon... +2026-04-29 09:30:06,988 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:07,608 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 5 hr time horizon... +2026-04-29 09:30:07,639 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:09,037 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 2 hr time horizon... +2026-04-29 09:30:09,058 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:09,381 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 3 hr time horizon... +2026-04-29 09:30:09,405 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:10,129 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 4 hr time horizon... +2026-04-29 09:30:10,150 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:10,960 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 9 hr time horizon... +2026-04-29 09:30:10,987 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:11,131 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 4 hr time horizon... +2026-04-29 09:30:11,151 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:11,596 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 4 hr time horizon... +2026-04-29 09:30:11,619 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:12,452 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 2 hr time horizon... +2026-04-29 09:30:12,473 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:13,144 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:13,168 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:14,219 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:14,243 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:14,899 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 16 hr time horizon... +2026-04-29 09:30:14,924 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:15,196 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 8 hr time horizon... +2026-04-29 09:30:15,221 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:15,404 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 17 hr time horizon... +2026-04-29 09:30:15,434 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:15,447 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 14 hr time horizon... +2026-04-29 09:30:15,467 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:17,144 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 6 hr time horizon... +2026-04-29 09:30:17,166 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 10 hr time horizon... +2026-04-29 09:30:17,264 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 18 hr time horizon... +2026-04-29 09:30:17,288 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:18,722 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 9 hr time horizon... +2026-04-29 09:30:18,743 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:20,803 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 11 hr time horizon... +2026-04-29 09:30:20,824 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:22,482 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 14 hr time horizon... +2026-04-29 09:30:22,505 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:22,630 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 1 hr time horizon... +2026-04-29 09:30:22,650 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:24,308 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 3 hr time horizon... +2026-04-29 09:30:24,327 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:24,624 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 4 hr time horizon... +2026-04-29 09:30:24,654 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:25,966 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 4 hr time horizon... +2026-04-29 09:30:25,987 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:26,314 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:30:26,339 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:26,472 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 3 hr time horizon... +2026-04-29 09:30:26,492 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:27,796 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:27,820 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:28,228 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 8 hr time horizon... +2026-04-29 09:30:28,253 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:29,320 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 4 hr time horizon... +2026-04-29 09:30:29,345 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:30,075 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 12 hr time horizon... +2026-04-29 09:30:30,106 - __main__ - INFO - Processing values: 2018-01-24 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:30,252 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:30,273 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:31,091 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 16 hr time horizon... +2026-04-29 09:30:31,115 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:32,084 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 17 hr time horizon... +2026-04-29 09:30:32,110 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:32,607 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 6 hr time horizon... +2026-04-29 09:30:32,628 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:33,101 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 10 hr time horizon... +2026-04-29 09:30:33,125 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 14 hr time horizon... +2026-04-29 09:30:33,556 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 18 hr time horizon... +2026-04-29 09:30:33,584 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:33,653 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 2 hr time horizon... +2026-04-29 09:30:33,676 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:36,369 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 4 hr time horizon... +2026-04-29 09:30:36,397 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:37,296 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 2 hr time horizon... +2026-04-29 09:30:37,315 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:38,143 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 16 hr time horizon... +2026-04-29 09:30:38,169 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:39,209 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 9 hr time horizon... +2026-04-29 09:30:39,233 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:39,867 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:39,895 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:41,288 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 13 hr time horizon... +2026-04-29 09:30:41,311 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:41,493 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 10 hr time horizon... +2026-04-29 09:30:41,517 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:42,220 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 17 hr time horizon... +2026-04-29 09:30:42,248 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:42,811 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 2 hr time horizon... +2026-04-29 09:30:42,832 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:43,009 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 12 hr time horizon... +2026-04-29 09:30:43,033 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:44,467 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 14 hr time horizon... +2026-04-29 09:30:44,488 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 5 hr time horizon... +2026-04-29 09:30:44,494 - __main__ - INFO - Finished processing 2018-01-24 16:00:00 10 hr time horizon... +2026-04-29 09:30:44,520 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:45,717 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 17 hr time horizon... +2026-04-29 09:30:45,745 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:47,092 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:47,115 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:47,969 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 1 hr time horizon... +2026-04-29 09:30:47,991 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:48,466 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 17 hr time horizon... +2026-04-29 09:30:48,490 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 17 hr time horizon... +2026-04-29 09:30:48,506 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 10 hr time horizon... +2026-04-29 09:30:48,535 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 2 hr time horizon... +2026-04-29 09:30:48,702 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 14 hr time horizon... +2026-04-29 09:30:48,726 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:50,997 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 9 hr time horizon... +2026-04-29 09:30:51,017 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:51,893 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 8 hr time horizon... +2026-04-29 09:30:51,918 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 15 hr time horizon... +2026-04-29 09:30:51,943 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 2 hr time horizon... +2026-04-29 09:30:51,966 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:52,794 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 17 hr time horizon... +2026-04-29 09:30:52,818 - __main__ - INFO - Processing values: 2018-01-21 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:55,643 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 17 hr time horizon... +2026-04-29 09:30:55,667 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:55,837 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 1 hr time horizon... +2026-04-29 09:30:55,855 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:56,406 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 12 hr time horizon... +2026-04-29 09:30:56,436 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:56,505 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 17 hr time horizon... +2026-04-29 09:30:56,525 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:57,654 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 15 hr time horizon... +2026-04-29 09:30:57,676 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:57,826 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 7 hr time horizon... +2026-04-29 09:30:57,857 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:57,966 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 18 hr time horizon... +2026-04-29 09:30:57,987 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:30:59,565 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 3 hr time horizon... +2026-04-29 09:30:59,586 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:00,081 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 5 hr time horizon... +2026-04-29 09:31:00,102 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:00,721 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 5 hr time horizon... +2026-04-29 09:31:00,743 - __main__ - INFO - Processing values: 2018-01-24 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:01,323 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 18 hr time horizon... +2026-04-29 09:31:01,348 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:03,676 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:03,695 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:04,734 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 14 hr time horizon... +2026-04-29 09:31:04,760 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:04,934 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 14 hr time horizon... +2026-04-29 09:31:04,937 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 17 hr time horizon... +2026-04-29 09:31:04,971 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 8 hr time horizon... +2026-04-29 09:31:04,976 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:06,679 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 3 hr time horizon... +2026-04-29 09:31:06,700 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:08,042 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 9 hr time horizon... +2026-04-29 09:31:08,068 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:08,349 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 15 hr time horizon... +2026-04-29 09:31:08,373 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:08,900 - __main__ - INFO - Finished processing 2018-01-21 19:00:00 8 hr time horizon... +2026-04-29 09:31:08,921 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:11,226 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 14 hr time horizon... +2026-04-29 09:31:11,250 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:11,387 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:11,410 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:11,835 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 1 hr time horizon... +2026-04-29 09:31:11,859 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:13,034 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 4 hr time horizon... +2026-04-29 09:31:13,056 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:13,274 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 12 hr time horizon... +2026-04-29 09:31:13,296 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:13,924 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 7 hr time horizon... +2026-04-29 09:31:13,946 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:14,007 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 18 hr time horizon... +2026-04-29 09:31:14,030 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:14,817 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:14,845 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:15,760 - __main__ - INFO - Finished processing 2018-01-24 20:00:00 11 hr time horizon... +2026-04-29 09:31:15,780 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:16,212 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 16 hr time horizon... +2026-04-29 09:31:16,235 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:16,415 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 9 hr time horizon... +2026-04-29 09:31:16,437 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:18,747 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 1 hr time horizon... +2026-04-29 09:31:18,767 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:19,729 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 7 hr time horizon... +2026-04-29 09:31:19,755 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:19,978 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 18 hr time horizon... +2026-04-29 09:31:19,996 - __main__ - INFO - Processing values: 2018-01-01 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:20,937 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 8 hr time horizon... +2026-04-29 09:31:20,961 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:22,613 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 15 hr time horizon... +2026-04-29 09:31:22,639 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:23,040 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:23,064 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:24,954 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 14 hr time horizon... +2026-04-29 09:31:24,978 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:25,705 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:25,730 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:25,835 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:25,857 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:26,694 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 14 hr time horizon... +2026-04-29 09:31:26,719 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:26,821 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:26,845 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 9 hr time horizon... +2026-04-29 09:31:26,871 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 17 hr time horizon... +2026-04-29 09:31:26,892 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:27,659 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 4 hr time horizon... +2026-04-29 09:31:27,680 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:27,944 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 16 hr time horizon... +2026-04-29 09:31:27,972 - __main__ - INFO - Processing values: 2018-01-11 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:29,189 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 14 hr time horizon... +2026-04-29 09:31:29,211 - __main__ - INFO - Processing values: 2018-01-15 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:29,320 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 11 hr time horizon... +2026-04-29 09:31:29,346 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 9 hr time horizon... +2026-04-29 09:31:29,351 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 8 hr time horizon... +2026-04-29 09:31:29,370 - __main__ - INFO - Processing values: 2018-01-17 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:30,196 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 17 hr time horizon... +2026-04-29 09:31:30,221 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:32,927 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 1 hr time horizon... +2026-04-29 09:31:32,945 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:34,595 - __main__ - INFO - Finished processing 2018-01-01 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:34,613 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:35,204 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 13 hr time horizon... +2026-04-29 09:31:35,237 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:36,088 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 16 hr time horizon... +2026-04-29 09:31:36,108 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 12 hr time horizon... +2026-04-29 09:31:36,155 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 15 hr time horizon... +2026-04-29 09:31:36,173 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:36,917 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 2 hr time horizon... +2026-04-29 09:31:36,939 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:39,862 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 11 hr time horizon... +2026-04-29 09:31:39,888 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:40,171 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 9 hr time horizon... +2026-04-29 09:31:40,191 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:40,710 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 12 hr time horizon... +2026-04-29 09:31:40,733 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:41,712 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 9 hr time horizon... +2026-04-29 09:31:41,734 - __main__ - INFO - Processing values: 2018-01-21 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:43,021 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 11 hr time horizon... +2026-04-29 09:31:43,038 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:44,328 - __main__ - INFO - Finished processing 2018-01-11 02:00:00 3 hr time horizon... +2026-04-29 09:31:44,349 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:46,114 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 17 hr time horizon... +2026-04-29 09:31:46,133 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:46,385 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 1 hr time horizon... +2026-04-29 09:31:46,404 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:47,348 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 11 hr time horizon... +2026-04-29 09:31:47,377 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:48,984 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 16 hr time horizon... +2026-04-29 09:31:49,013 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:49,707 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:49,727 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 1 hr time horizon... +2026-04-29 09:31:49,748 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:49,768 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 15 hr time horizon... +2026-04-29 09:31:49,769 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 14 hr time horizon... +2026-04-29 09:31:49,787 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:50,197 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 7 hr time horizon... +2026-04-29 09:31:50,220 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 16 hr time horizon... +2026-04-29 09:31:50,242 - __main__ - INFO - Finished processing 2018-01-15 16:00:00 16 hr time horizon... +2026-04-29 09:31:50,268 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:50,748 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 9 hr time horizon... +2026-04-29 09:31:50,769 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 12 hr time horizon... +2026-04-29 09:31:50,774 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:50,795 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:51,221 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 4 hr time horizon... +2026-04-29 09:31:51,244 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:53,136 - __main__ - INFO - Finished processing 2018-01-17 12:00:00 14 hr time horizon... +2026-04-29 09:31:53,159 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:53,644 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 16 hr time horizon... +2026-04-29 09:31:53,669 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:54,492 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 13 hr time horizon... +2026-04-29 09:31:54,513 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:55,055 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 16 hr time horizon... +2026-04-29 09:31:55,077 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:57,027 - __main__ - INFO - Finished processing 2018-01-21 19:00:00 9 hr time horizon... +2026-04-29 09:31:57,055 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:31:57,563 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 8 hr time horizon... +2026-04-29 09:31:57,587 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 13 hr time horizon... +2026-04-29 09:31:57,710 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 16 hr time horizon... +2026-04-29 09:31:57,730 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:00,006 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 2 hr time horizon... +2026-04-29 09:32:00,027 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:01,063 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 8 hr time horizon... +2026-04-29 09:32:01,086 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:02,734 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:02,757 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:03,174 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 12 hr time horizon... +2026-04-29 09:32:03,197 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:04,295 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 1 hr time horizon... +2026-04-29 09:32:04,313 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:04,515 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 5 hr time horizon... +2026-04-29 09:32:04,538 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:04,806 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 6 hr time horizon... +2026-04-29 09:32:04,829 - __main__ - INFO - Processing values: 2018-01-09 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:05,668 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 12 hr time horizon... +2026-04-29 09:32:05,693 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:06,259 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 10 hr time horizon... +2026-04-29 09:32:06,288 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:07,268 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:07,296 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:08,183 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 1 hr time horizon... +2026-04-29 09:32:08,203 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:09,392 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 13 hr time horizon... +2026-04-29 09:32:09,416 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:09,508 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 10 hr time horizon... +2026-04-29 09:32:09,530 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:10,670 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 17 hr time horizon... +2026-04-29 09:32:10,690 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:13,174 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:13,196 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:14,259 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 14 hr time horizon... +2026-04-29 09:32:14,284 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 1 hr time horizon... +2026-04-29 09:32:14,490 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 13 hr time horizon... +2026-04-29 09:32:14,516 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:14,871 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 15 hr time horizon... +2026-04-29 09:32:14,891 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:17,219 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:17,249 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:17,704 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 16 hr time horizon... +2026-04-29 09:32:17,724 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:18,292 - __main__ - INFO - Finished processing 2018-01-09 16:00:00 2 hr time horizon... +2026-04-29 09:32:18,315 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:18,623 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 5 hr time horizon... +2026-04-29 09:32:18,645 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 14 hr time horizon... +2026-04-29 09:32:18,737 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 17 hr time horizon... +2026-04-29 09:32:18,757 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:19,471 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 9 hr time horizon... +2026-04-29 09:32:19,494 - __main__ - INFO - Processing values: 2018-01-26 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:21,839 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 4 hr time horizon... +2026-04-29 09:32:21,862 - __main__ - INFO - Processing values: 2018-01-21 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:22,680 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 3 hr time horizon... +2026-04-29 09:32:22,698 - __main__ - INFO - Processing values: 2018-01-26 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:23,670 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 17 hr time horizon... +2026-04-29 09:32:23,689 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:23,914 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 5 hr time horizon... +2026-04-29 09:32:23,935 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:24,489 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 14 hr time horizon... +2026-04-29 09:32:24,509 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:26,960 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 1 hr time horizon... +2026-04-29 09:32:26,977 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:27,816 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 14 hr time horizon... +2026-04-29 09:32:27,836 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:31,773 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:31,796 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,025 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,047 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,466 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,486 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,567 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 2 hr time horizon... +2026-04-29 09:32:32,589 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:32,901 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 12 hr time horizon... +2026-04-29 09:32:32,918 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 9 hr time horizon... +2026-04-29 09:32:32,922 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 7 hr time horizon... +2026-04-29 09:32:32,938 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:33,106 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 4 hr time horizon... +2026-04-29 09:32:33,126 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:33,485 - __main__ - INFO - Finished processing 2018-01-26 00:00:00 5 hr time horizon... +2026-04-29 09:32:33,503 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:33,751 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 14 hr time horizon... +2026-04-29 09:32:33,771 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:34,345 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 14 hr time horizon... +2026-04-29 09:32:34,370 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:36,123 - __main__ - INFO - Finished processing 2018-01-21 07:00:00 6 hr time horizon... +2026-04-29 09:32:36,144 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:36,803 - __main__ - INFO - Finished processing 2018-01-26 00:00:00 2 hr time horizon... +2026-04-29 09:32:36,823 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:38,153 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 5 hr time horizon... +2026-04-29 09:32:38,182 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:39,254 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 12 hr time horizon... +2026-04-29 09:32:39,278 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 3 hr time horizon... +2026-04-29 09:32:39,392 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 14 hr time horizon... +2026-04-29 09:32:39,417 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:42,436 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 16 hr time horizon... +2026-04-29 09:32:42,461 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:42,818 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 17 hr time horizon... +2026-04-29 09:32:42,839 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:44,088 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:44,118 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:45,367 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:45,400 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:47,322 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:47,345 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:47,477 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 13 hr time horizon... +2026-04-29 09:32:47,506 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:47,742 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 5 hr time horizon... +2026-04-29 09:32:47,772 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:47,987 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 7 hr time horizon... +2026-04-29 09:32:48,008 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:48,279 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:48,300 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:48,399 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 4 hr time horizon... +2026-04-29 09:32:48,427 - __main__ - INFO - Processing values: 2018-01-05 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:48,790 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:48,812 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:49,346 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:32:49,370 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:50,007 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 11 hr time horizon... +2026-04-29 09:32:50,028 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:50,582 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 18 hr time horizon... +2026-04-29 09:32:50,612 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:52,594 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 10 hr time horizon... +2026-04-29 09:32:52,615 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:52,907 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:52,932 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:53,980 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:54,005 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:54,652 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 12 hr time horizon... +2026-04-29 09:32:54,674 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 2 hr time horizon... +2026-04-29 09:32:54,872 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 3 hr time horizon... +2026-04-29 09:32:54,895 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:58,123 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 15 hr time horizon... +2026-04-29 09:32:58,146 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:58,339 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 9 hr time horizon... +2026-04-29 09:32:58,365 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:59,653 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 1 hr time horizon... +2026-04-29 09:32:59,673 - __main__ - INFO - Processing values: 2018-01-04 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:32:59,826 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 17 hr time horizon... +2026-04-29 09:32:59,853 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:02,266 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:02,289 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:02,769 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 8 hr time horizon... +2026-04-29 09:33:02,791 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:02,941 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 7 hr time horizon... +2026-04-29 09:33:02,963 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:03,051 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 1 hr time horizon... +2026-04-29 09:33:03,070 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:03,728 - __main__ - INFO - Finished processing 2018-01-05 02:00:00 17 hr time horizon... +2026-04-29 09:33:03,761 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:04,178 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 18 hr time horizon... +2026-04-29 09:33:04,201 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:04,284 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 10 hr time horizon... +2026-04-29 09:33:04,309 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:05,238 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 5 hr time horizon... +2026-04-29 09:33:05,258 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:05,530 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 11 hr time horizon... +2026-04-29 09:33:05,552 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:06,623 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 2 hr time horizon... +2026-04-29 09:33:06,647 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:07,883 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 2 hr time horizon... +2026-04-29 09:33:07,903 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:08,813 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 9 hr time horizon... +2026-04-29 09:33:08,838 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:09,364 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 2 hr time horizon... +2026-04-29 09:33:09,383 - __main__ - INFO - Processing values: 2018-01-24 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:10,681 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 15 hr time horizon... +2026-04-29 09:33:10,704 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:12,668 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 4 hr time horizon... +2026-04-29 09:33:12,687 - __main__ - INFO - Processing values: 2018-01-18 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:12,966 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 3 hr time horizon... +2026-04-29 09:33:12,989 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:13,148 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 4 hr time horizon... +2026-04-29 09:33:13,168 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:14,565 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 17 hr time horizon... +2026-04-29 09:33:14,586 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:14,744 - __main__ - INFO - Finished processing 2018-01-04 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:14,769 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:16,237 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 9 hr time horizon... +2026-04-29 09:33:16,259 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:16,578 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 15 hr time horizon... +2026-04-29 09:33:16,600 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:16,734 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 4 hr time horizon... +2026-04-29 09:33:16,758 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:16,858 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 2 hr time horizon... +2026-04-29 09:33:16,875 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:17,438 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 15 hr time horizon... +2026-04-29 09:33:17,465 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:18,581 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 6 hr time horizon... +2026-04-29 09:33:18,601 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:18,864 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 11 hr time horizon... +2026-04-29 09:33:18,884 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:19,555 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 17 hr time horizon... +2026-04-29 09:33:19,580 - __main__ - INFO - Processing values: 2018-01-15 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:20,286 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 12 hr time horizon... +2026-04-29 09:33:20,310 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:21,644 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 16 hr time horizon... +2026-04-29 09:33:21,667 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:22,552 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 7 hr time horizon... +2026-04-29 09:33:22,572 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 5 hr time horizon... +2026-04-29 09:33:22,783 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 14 hr time horizon... +2026-04-29 09:33:22,804 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 13 hr time horizon... +2026-04-29 09:33:22,971 - __main__ - INFO - Finished processing 2018-01-24 17:00:00 8 hr time horizon... +2026-04-29 09:33:22,990 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:26,542 - __main__ - INFO - Finished processing 2018-01-18 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:26,566 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:27,149 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 17 hr time horizon... +2026-04-29 09:33:27,169 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 8 hr time horizon... +2026-04-29 09:33:27,279 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 8 hr time horizon... +2026-04-29 09:33:27,300 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:27,431 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 3 hr time horizon... +2026-04-29 09:33:27,457 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:29,584 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:29,613 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:30,137 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 17 hr time horizon... +2026-04-29 09:33:30,159 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:30,169 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 9 hr time horizon... +2026-04-29 09:33:30,190 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 8 hr time horizon... +2026-04-29 09:33:30,200 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 7 hr time horizon... +2026-04-29 09:33:30,219 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:30,541 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:30,564 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:31,743 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 13 hr time horizon... +2026-04-29 09:33:31,763 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 17 hr time horizon... +2026-04-29 09:33:31,929 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 17 hr time horizon... +2026-04-29 09:33:31,955 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:33,112 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 17 hr time horizon... +2026-04-29 09:33:33,133 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:34,182 - __main__ - INFO - Finished processing 2018-01-15 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:34,203 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:35,464 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:35,495 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:36,057 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 9 hr time horizon... +2026-04-29 09:33:36,087 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:36,573 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 14 hr time horizon... +2026-04-29 09:33:36,600 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:37,190 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 5 hr time horizon... +2026-04-29 09:33:37,224 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 14 hr time horizon... +2026-04-29 09:33:37,386 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 13 hr time horizon... +2026-04-29 09:33:37,409 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:37,772 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:37,806 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:40,346 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 13 hr time horizon... +2026-04-29 09:33:40,378 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:41,229 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 8 hr time horizon... +2026-04-29 09:33:41,250 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:41,393 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 10 hr time horizon... +2026-04-29 09:33:41,414 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:42,072 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 2 hr time horizon... +2026-04-29 09:33:42,099 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:33:43,600 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:43,625 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:44,273 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 1 hr time horizon... +2026-04-29 09:33:44,295 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:44,463 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 6 hr time horizon... +2026-04-29 09:33:44,484 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:44,856 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:44,880 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 2 hr time horizon... +2026-04-29 09:33:44,958 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 10 hr time horizon... +2026-04-29 09:33:44,978 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:45,519 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 2 hr time horizon... +2026-04-29 09:33:45,547 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:48,100 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:48,124 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:49,248 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 3 hr time horizon... +2026-04-29 09:33:49,267 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:49,429 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:49,458 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:33:50,602 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:50,627 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 7 hr time horizon... +2026-04-29 09:33:50,761 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 5 hr time horizon... +2026-04-29 09:33:50,780 - __main__ - INFO - Processing values: 2018-01-03 06:00:00 14 hr time horizon... +2026-04-29 09:33:50,854 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 13 hr time horizon... +2026-04-29 09:33:50,874 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:50,941 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 14 hr time horizon... +2026-04-29 09:33:50,965 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:52,237 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 14 hr time horizon... +2026-04-29 09:33:52,263 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:52,912 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:52,938 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:54,282 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 12 hr time horizon... +2026-04-29 09:33:54,304 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:55,736 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 8 hr time horizon... +2026-04-29 09:33:55,758 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:56,083 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 6 hr time horizon... +2026-04-29 09:33:56,105 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:56,250 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:56,275 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:57,536 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 15 hr time horizon... +2026-04-29 09:33:57,566 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:58,079 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 2 hr time horizon... +2026-04-29 09:33:58,098 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:58,370 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 6 hr time horizon... +2026-04-29 09:33:58,399 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:58,946 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 1 hr time horizon... +2026-04-29 09:33:58,967 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:33:59,277 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 7 hr time horizon... +2026-04-29 09:33:59,295 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 15 hr time horizon... +2026-04-29 09:33:59,456 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 5 hr time horizon... +2026-04-29 09:33:59,482 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:01,936 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 16 hr time horizon... +2026-04-29 09:34:01,956 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:04,599 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 9 hr time horizon... +2026-04-29 09:34:04,621 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:04,843 - __main__ - INFO - Finished processing 2018-01-03 06:00:00 14 hr time horizon... +2026-04-29 09:34:04,864 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:05,179 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 4 hr time horizon... +2026-04-29 09:34:05,213 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:05,704 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 14 hr time horizon... +2026-04-29 09:34:05,726 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:08,078 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 16 hr time horizon... +2026-04-29 09:34:08,108 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:08,255 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 16 hr time horizon... +2026-04-29 09:34:08,282 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:08,968 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:08,997 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:09,672 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 9 hr time horizon... +2026-04-29 09:34:09,695 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:09,862 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 10 hr time horizon... +2026-04-29 09:34:09,886 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:12,016 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 14 hr time horizon... +2026-04-29 09:34:12,042 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:34:12,402 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:12,427 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:12,544 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 13 hr time horizon... +2026-04-29 09:34:12,564 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 17 hr time horizon... +2026-04-29 09:34:12,580 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 17 hr time horizon... +2026-04-29 09:34:12,601 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:12,783 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 8 hr time horizon... +2026-04-29 09:34:12,804 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:13,149 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 15 hr time horizon... +2026-04-29 09:34:13,168 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:14,075 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 10 hr time horizon... +2026-04-29 09:34:14,097 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:16,295 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:16,320 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:18,426 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 7 hr time horizon... +2026-04-29 09:34:18,448 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:18,531 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 7 hr time horizon... +2026-04-29 09:34:18,560 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:19,005 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 13 hr time horizon... +2026-04-29 09:34:19,030 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:19,138 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 6 hr time horizon... +2026-04-29 09:34:19,160 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:19,465 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 4 hr time horizon... +2026-04-29 09:34:19,487 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:20,381 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 14 hr time horizon... +2026-04-29 09:34:20,403 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:22,457 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 1 hr time horizon... +2026-04-29 09:34:22,476 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:23,858 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 15 hr time horizon... +2026-04-29 09:34:23,886 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:24,366 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 2 hr time horizon... +2026-04-29 09:34:24,387 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:24,950 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:24,978 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:26,954 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:26,983 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:27,143 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:27,166 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:27,799 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 16 hr time horizon... +2026-04-29 09:34:27,824 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:27,906 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 1 hr time horizon... +2026-04-29 09:34:27,928 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:28,047 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 4 hr time horizon... +2026-04-29 09:34:28,073 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:28,358 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 17 hr time horizon... +2026-04-29 09:34:28,381 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 6 hr time horizon... +2026-04-29 09:34:28,709 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 18 hr time horizon... +2026-04-29 09:34:28,739 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:29,783 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 14 hr time horizon... +2026-04-29 09:34:29,808 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:31,758 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:31,783 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:33,820 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 12 hr time horizon... +2026-04-29 09:34:33,844 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:34,030 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 5 hr time horizon... +2026-04-29 09:34:34,053 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:34,595 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 8 hr time horizon... +2026-04-29 09:34:34,616 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 6 hr time horizon... +2026-04-29 09:34:34,724 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 9 hr time horizon... +2026-04-29 09:34:34,745 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:35,031 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 13 hr time horizon... +2026-04-29 09:34:35,056 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:36,141 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 18 hr time horizon... +2026-04-29 09:34:36,163 - __main__ - INFO - Processing values: 2018-01-29 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:37,868 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 2 hr time horizon... +2026-04-29 09:34:37,889 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:38,743 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 11 hr time horizon... +2026-04-29 09:34:38,767 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:39,221 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 16 hr time horizon... +2026-04-29 09:34:39,252 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:39,648 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 16 hr time horizon... +2026-04-29 09:34:39,670 - __main__ - INFO - Processing values: 2018-01-02 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:41,831 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 7 hr time horizon... +2026-04-29 09:34:41,853 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 13 hr time horizon... +2026-04-29 09:34:41,856 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 2 hr time horizon... +2026-04-29 09:34:41,875 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:43,454 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 8 hr time horizon... +2026-04-29 09:34:43,485 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:43,589 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 6 hr time horizon... +2026-04-29 09:34:43,612 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:44,081 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 18 hr time horizon... +2026-04-29 09:34:44,104 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:44,203 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 15 hr time horizon... +2026-04-29 09:34:44,224 - __main__ - INFO - Processing values: 2018-01-13 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:45,839 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 9 hr time horizon... +2026-04-29 09:34:45,863 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:45,995 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 16 hr time horizon... +2026-04-29 09:34:46,017 - __main__ - INFO - Processing values: 2018-01-13 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:47,869 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 14 hr time horizon... +2026-04-29 09:34:47,893 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:48,780 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 3 hr time horizon... +2026-04-29 09:34:48,804 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:48,968 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 9 hr time horizon... +2026-04-29 09:34:48,990 - __main__ - INFO - Processing values: 2018-01-29 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/core.py:1114: UserWarning: Will not remove GRIB file because it previously existed. + warnings.warn("Will not remove GRIB file because it previously existed.") +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:49,262 - __main__ - INFO - No valid message found: PosixPath('/home/kperry/data/hrrr/20180109/subset_1d21165b__hrrr.t12z.wrfprsf02.grib2') +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:49,343 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 14 hr time horizon... +2026-04-29 09:34:49,362 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:50,278 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 6 hr time horizon... +2026-04-29 09:34:50,302 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:50,941 - __main__ - INFO - Finished processing 2018-01-29 07:00:00 14 hr time horizon... +2026-04-29 09:34:50,962 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:53,597 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:53,617 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:54,150 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 12 hr time horizon... +2026-04-29 09:34:54,169 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 2 hr time horizon... +2026-04-29 09:34:54,186 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 12 hr time horizon... +2026-04-29 09:34:54,209 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 17 hr time horizon... +2026-04-29 09:34:54,263 - __main__ - INFO - Download failed for {date} {time_horizon} hr time horizon... +2026-04-29 09:34:54,265 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:54,403 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 13 hr time horizon... +2026-04-29 09:34:54,432 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:55,023 - __main__ - INFO - Finished processing 2018-01-02 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:55,050 - __main__ - INFO - Processing values: 2018-01-05 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:56,594 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 2 hr time horizon... +2026-04-29 09:34:56,615 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:57,374 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 6 hr time horizon... +2026-04-29 09:34:57,397 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:58,142 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 10 hr time horizon... +2026-04-29 09:34:58,169 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:58,746 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 11 hr time horizon... +2026-04-29 09:34:58,777 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:58,914 - __main__ - INFO - Finished processing 2018-01-13 09:00:00 9 hr time horizon... +2026-04-29 09:34:58,934 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:34:59,509 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 7 hr time horizon... +2026-04-29 09:34:59,529 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:00,673 - __main__ - INFO - Finished processing 2018-01-13 13:00:00 3 hr time horizon... +2026-04-29 09:35:00,704 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:00,916 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 1 hr time horizon... +2026-04-29 09:35:00,938 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:03,147 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 12 hr time horizon... +2026-04-29 09:35:03,172 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:03,689 - __main__ - INFO - Finished processing 2018-01-29 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:03,710 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:04,492 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 11 hr time horizon... +2026-04-29 09:35:04,516 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:05,012 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 5 hr time horizon... +2026-04-29 09:35:05,034 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:05,768 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 1 hr time horizon... +2026-04-29 09:35:05,789 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:35:08,507 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:08,530 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:09,370 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 8 hr time horizon... +2026-04-29 09:35:09,393 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 12 hr time horizon... +2026-04-29 09:35:09,543 - __main__ - INFO - Finished processing 2018-01-05 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:09,566 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:09,592 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 17 hr time horizon... +2026-04-29 09:35:09,620 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:09,702 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 2 hr time horizon... +2026-04-29 09:35:09,723 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:10,185 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 17 hr time horizon... +2026-04-29 09:35:10,205 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:10,639 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 18 hr time horizon... +2026-04-29 09:35:10,659 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:12,429 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:12,452 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:13,366 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 12 hr time horizon... +2026-04-29 09:35:13,393 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:13,849 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 16 hr time horizon... +2026-04-29 09:35:13,870 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 13 hr time horizon... +2026-04-29 09:35:13,973 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 13 hr time horizon... +2026-04-29 09:35:13,996 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:15,481 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 14 hr time horizon... +2026-04-29 09:35:15,506 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:17,207 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 14 hr time horizon... +2026-04-29 09:35:17,231 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:17,975 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 12 hr time horizon... +2026-04-29 09:35:17,994 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:18,739 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 5 hr time horizon... +2026-04-29 09:35:18,761 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:19,344 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 6 hr time horizon... +2026-04-29 09:35:19,365 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:20,017 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 10 hr time horizon... +2026-04-29 09:35:20,042 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:20,590 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 7 hr time horizon... +2026-04-29 09:35:20,614 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:23,090 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 3 hr time horizon... +2026-04-29 09:35:23,113 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:24,205 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 12 hr time horizon... +2026-04-29 09:35:24,229 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:24,407 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 12 hr time horizon... +2026-04-29 09:35:24,435 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 2 hr time horizon... +2026-04-29 09:35:24,449 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:24,474 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 1 hr time horizon... +2026-04-29 09:35:24,731 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 6 hr time horizon... +2026-04-29 09:35:24,754 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:24,936 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 12 hr time horizon... +2026-04-29 09:35:24,956 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:27,050 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 18 hr time horizon... +2026-04-29 09:35:27,078 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:28,475 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 8 hr time horizon... +2026-04-29 09:35:28,496 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:28,683 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 7 hr time horizon... +2026-04-29 09:35:28,710 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:28,929 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 8 hr time horizon... +2026-04-29 09:35:28,952 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:29,197 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 13 hr time horizon... +2026-04-29 09:35:29,224 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:30,917 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 8 hr time horizon... +2026-04-29 09:35:30,948 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:32,275 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 17 hr time horizon... +2026-04-29 09:35:32,323 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:32,491 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:32,528 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:33,638 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 7 hr time horizon... +2026-04-29 09:35:33,657 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:34,956 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 9 hr time horizon... +2026-04-29 09:35:34,980 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:35,119 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 8 hr time horizon... +2026-04-29 09:35:35,140 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 18 hr time horizon... +2026-04-29 09:35:35,462 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 13 hr time horizon... +2026-04-29 09:35:35,485 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:35,639 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 5 hr time horizon... +2026-04-29 09:35:35,662 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:38,559 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 12 hr time horizon... +2026-04-29 09:35:38,586 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:39,038 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:39,059 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:39,301 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 1 hr time horizon... +2026-04-29 09:35:39,323 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:39,514 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 15 hr time horizon... +2026-04-29 09:35:39,536 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:39,870 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 15 hr time horizon... +2026-04-29 09:35:39,891 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:40,084 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 2 hr time horizon... +2026-04-29 09:35:40,104 - __main__ - INFO - Processing values: 2018-01-22 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:41,683 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 5 hr time horizon... +2026-04-29 09:35:41,706 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:43,396 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 11 hr time horizon... +2026-04-29 09:35:43,418 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:44,201 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 17 hr time horizon... +2026-04-29 09:35:44,221 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:44,414 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 3 hr time horizon... +2026-04-29 09:35:44,443 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:45,098 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 14 hr time horizon... +2026-04-29 09:35:45,121 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:47,169 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 5 hr time horizon... +2026-04-29 09:35:47,190 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:48,634 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 11 hr time horizon... +2026-04-29 09:35:48,658 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:49,895 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 18 hr time horizon... +2026-04-29 09:35:49,929 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:50,064 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 1 hr time horizon... +2026-04-29 09:35:50,083 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 18 hr time horizon... +2026-04-29 09:35:50,110 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 12 hr time horizon... +2026-04-29 09:35:50,139 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:50,385 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:50,408 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:51,418 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 6 hr time horizon... +2026-04-29 09:35:51,442 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:52,230 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 7 hr time horizon... +2026-04-29 09:35:52,262 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:53,668 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 3 hr time horizon... +2026-04-29 09:35:53,689 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:54,246 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 8 hr time horizon... +2026-04-29 09:35:54,268 - __main__ - INFO - Processing values: 2018-01-19 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:54,415 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 12 hr time horizon... +2026-04-29 09:35:54,440 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:54,535 - __main__ - INFO - Finished processing 2018-01-22 12:00:00 1 hr time horizon... +2026-04-29 09:35:54,555 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 14 hr time horizon... +2026-04-29 09:35:54,700 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 8 hr time horizon... +2026-04-29 09:35:54,723 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:57,366 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 4 hr time horizon... +2026-04-29 09:35:57,389 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:57,402 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 2 hr time horizon... +2026-04-29 09:35:57,425 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:58,833 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 6 hr time horizon... +2026-04-29 09:35:58,858 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:59,630 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:59,650 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 16 hr time horizon... +2026-04-29 09:35:59,782 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:35:59,804 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:00,251 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 13 hr time horizon... +2026-04-29 09:36:00,273 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:01,379 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 11 hr time horizon... +2026-04-29 09:36:01,399 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:03,520 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 15 hr time horizon... +2026-04-29 09:36:03,539 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:04,393 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 1 hr time horizon... +2026-04-29 09:36:04,411 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:04,687 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 7 hr time horizon... +2026-04-29 09:36:04,707 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:05,670 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 8 hr time horizon... +2026-04-29 09:36:05,690 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:08,622 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 1 hr time horizon... +2026-04-29 09:36:08,639 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:09,624 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 18 hr time horizon... +2026-04-29 09:36:09,644 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:15,361 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 8 hr time horizon... +2026-04-29 09:36:15,386 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:15,897 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 6 hr time horizon... +2026-04-29 09:36:15,916 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:16,899 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 2 hr time horizon... +2026-04-29 09:36:16,923 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:17,475 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 17 hr time horizon... +2026-04-29 09:36:17,494 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 11 hr time horizon... +2026-04-29 09:36:17,836 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 11 hr time horizon... +2026-04-29 09:36:17,853 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 16 hr time horizon... +2026-04-29 09:36:17,920 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 8 hr time horizon... +2026-04-29 09:36:17,938 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:20,840 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 3 hr time horizon... +2026-04-29 09:36:20,856 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:21,932 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 3 hr time horizon... +2026-04-29 09:36:21,948 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:28,044 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 18 hr time horizon... +2026-04-29 09:36:28,062 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:29,228 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 7 hr time horizon... +2026-04-29 09:36:29,247 - __main__ - INFO - Processing values: 2018-01-30 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:30,302 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 11 hr time horizon... +2026-04-29 09:36:30,319 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 11 hr time horizon... +2026-04-29 09:36:30,357 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 16 hr time horizon... +2026-04-29 09:36:30,374 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:31,088 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 9 hr time horizon... +2026-04-29 09:36:31,105 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:31,971 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 14 hr time horizon... +2026-04-29 09:36:31,994 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:33,456 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 12 hr time horizon... +2026-04-29 09:36:33,478 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:34,291 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 10 hr time horizon... +2026-04-29 09:36:34,310 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:37,646 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 1 hr time horizon... +2026-04-29 09:36:37,661 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:40,505 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 14 hr time horizon... +2026-04-29 09:36:40,521 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:42,370 - __main__ - INFO - Finished processing 2018-01-30 04:00:00 7 hr time horizon... +2026-04-29 09:36:42,393 - __main__ - INFO - Processing values: 2018-01-07 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:43,158 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 11 hr time horizon... +2026-04-29 09:36:43,176 - __main__ - INFO - Processing values: 2018-01-18 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:44,053 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:44,072 - __main__ - INFO - Processing values: 2018-01-26 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:44,145 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 10 hr time horizon... +2026-04-29 09:36:44,167 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:44,716 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 11 hr time horizon... +2026-04-29 09:36:44,738 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 2 hr time horizon... +2026-04-29 09:36:44,856 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 14 hr time horizon... +2026-04-29 09:36:44,875 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:45,920 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 4 hr time horizon... +2026-04-29 09:36:45,939 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:50,147 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 7 hr time horizon... +2026-04-29 09:36:50,166 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 17 hr time horizon... +2026-04-29 09:36:50,241 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 3 hr time horizon... +2026-04-29 09:36:50,259 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:52,626 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 2 hr time horizon... +2026-04-29 09:36:52,642 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:53,393 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 16 hr time horizon... +2026-04-29 09:36:53,411 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:55,731 - __main__ - INFO - Finished processing 2018-01-07 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:55,760 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:56,560 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 8 hr time horizon... +2026-04-29 09:36:56,589 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:56,981 - __main__ - INFO - Finished processing 2018-01-19 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:57,002 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:57,352 - __main__ - INFO - Finished processing 2018-01-26 21:00:00 16 hr time horizon... +2026-04-29 09:36:57,373 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:57,756 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 2 hr time horizon... +2026-04-29 09:36:57,773 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:57,835 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 14 hr time horizon... +2026-04-29 09:36:57,853 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 17 hr time horizon... +2026-04-29 09:36:57,894 - __main__ - INFO - Finished processing 2018-01-18 03:00:00 3 hr time horizon... +2026-04-29 09:36:57,913 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:36:58,508 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 17 hr time horizon... +2026-04-29 09:36:58,529 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 15 hr time horizon... +2026-04-29 09:36:59,008 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 4 hr time horizon... +2026-04-29 09:36:59,027 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:02,811 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 14 hr time horizon... +2026-04-29 09:37:02,830 - __main__ - INFO - Processing values: 2018-01-03 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:05,885 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 10 hr time horizon... +2026-04-29 09:37:05,902 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:09,437 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 13 hr time horizon... +2026-04-29 09:37:09,456 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:10,426 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:10,452 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:10,497 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 12 hr time horizon... +2026-04-29 09:37:10,521 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:11,153 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 5 hr time horizon... +2026-04-29 09:37:11,172 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:11,487 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 10 hr time horizon... +2026-04-29 09:37:11,511 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:11,650 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 9 hr time horizon... +2026-04-29 09:37:11,671 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 17 hr time horizon... +2026-04-29 09:37:11,693 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:11,714 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:12,618 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 15 hr time horizon... +2026-04-29 09:37:12,629 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 4 hr time horizon... +2026-04-29 09:37:12,644 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 7 hr time horizon... +2026-04-29 09:37:12,655 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 5 hr time horizon... +2026-04-29 09:37:13,122 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 17 hr time horizon... +2026-04-29 09:37:13,141 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:17,077 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 17 hr time horizon... +2026-04-29 09:37:17,098 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:18,941 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 1 hr time horizon... +2026-04-29 09:37:18,959 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:20,819 - __main__ - INFO - Finished processing 2018-01-03 17:00:00 5 hr time horizon... +2026-04-29 09:37:20,850 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:23,473 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:23,495 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,029 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 15 hr time horizon... +2026-04-29 09:37:24,057 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,078 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,103 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,554 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 14 hr time horizon... +2026-04-29 09:37:24,577 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,800 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 3 hr time horizon... +2026-04-29 09:37:24,820 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,847 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 11 hr time horizon... +2026-04-29 09:37:24,868 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:24,991 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 5 hr time horizon... +2026-04-29 09:37:25,014 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:25,124 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:25,149 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:26,051 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 7 hr time horizon... +2026-04-29 09:37:26,078 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:26,585 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 5 hr time horizon... +2026-04-29 09:37:26,607 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:26,898 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 3 hr time horizon... +2026-04-29 09:37:26,918 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:28,098 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 5 hr time horizon... +2026-04-29 09:37:28,125 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 15 hr time horizon... +2026-04-29 09:37:28,250 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 16 hr time horizon... +2026-04-29 09:37:28,279 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:31,086 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:31,109 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:32,050 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 8 hr time horizon... +2026-04-29 09:37:32,073 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:34,325 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 5 hr time horizon... +2026-04-29 09:37:34,349 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:35,377 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 3 hr time horizon... +2026-04-29 09:37:35,401 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:37,624 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:37,647 - __main__ - INFO - Processing values: 2018-01-05 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:38,029 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 17 hr time horizon... +2026-04-29 09:37:38,060 - __main__ - INFO - Processing values: 2018-01-29 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:38,178 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 11 hr time horizon... +2026-04-29 09:37:38,198 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:38,377 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 9 hr time horizon... +2026-04-29 09:37:38,396 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:38,797 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 8 hr time horizon... +2026-04-29 09:37:38,829 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:39,928 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 12 hr time horizon... +2026-04-29 09:37:39,951 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 2 hr time horizon... +2026-04-29 09:37:40,034 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 2 hr time horizon... +2026-04-29 09:37:40,062 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:40,232 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 13 hr time horizon... +2026-04-29 09:37:40,262 - __main__ - INFO - Processing values: 2018-01-13 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:41,580 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:41,600 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:41,734 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 9 hr time horizon... +2026-04-29 09:37:41,757 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:42,194 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 6 hr time horizon... +2026-04-29 09:37:42,216 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:42,822 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 5 hr time horizon... +2026-04-29 09:37:42,846 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:43,013 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 15 hr time horizon... +2026-04-29 09:37:43,036 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:45,482 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:45,505 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 12 hr time horizon... +2026-04-29 09:37:45,622 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 9 hr time horizon... +2026-04-29 09:37:45,645 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:46,093 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 1 hr time horizon... +2026-04-29 09:37:46,118 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:48,603 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 11 hr time horizon... +2026-04-29 09:37:48,623 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:49,019 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 9 hr time horizon... +2026-04-29 09:37:49,038 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:50,661 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:50,687 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:51,397 - __main__ - INFO - Finished processing 2018-01-05 12:00:00 6 hr time horizon... +2026-04-29 09:37:51,430 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:51,640 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 18 hr time horizon... +2026-04-29 09:37:51,663 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:52,593 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 15 hr time horizon... +2026-04-29 09:37:52,616 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:53,349 - __main__ - INFO - Finished processing 2018-01-29 15:00:00 3 hr time horizon... +2026-04-29 09:37:53,370 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:53,802 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 13 hr time horizon... +2026-04-29 09:37:53,823 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:54,073 - __main__ - INFO - Finished processing 2018-01-13 06:00:00 16 hr time horizon... +2026-04-29 09:37:54,092 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:54,371 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 6 hr time horizon... +2026-04-29 09:37:54,393 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:54,497 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 2 hr time horizon... +2026-04-29 09:37:54,515 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:54,767 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 1 hr time horizon... +2026-04-29 09:37:54,787 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:55,935 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 7 hr time horizon... +2026-04-29 09:37:55,959 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:56,889 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 13 hr time horizon... +2026-04-29 09:37:56,924 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:57,411 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:37:57,444 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:58,457 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 14 hr time horizon... +2026-04-29 09:37:58,479 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:37:59,731 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 11 hr time horizon... +2026-04-29 09:37:59,754 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 4 hr time horizon... +2026-04-29 09:37:59,918 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 8 hr time horizon... +2026-04-29 09:37:59,941 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:02,637 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 4 hr time horizon... +2026-04-29 09:38:02,661 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:03,440 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 1 hr time horizon... +2026-04-29 09:38:03,463 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,035 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 15 hr time horizon... +2026-04-29 09:38:08,038 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 18 hr time horizon... +2026-04-29 09:38:08,049 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 11 hr time horizon... +2026-04-29 09:38:08,075 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 6 hr time horizon... +2026-04-29 09:38:08,082 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 8 hr time horizon... +2026-04-29 09:38:08,089 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,118 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 5 hr time horizon... +2026-04-29 09:38:08,144 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,320 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 10 hr time horizon... +2026-04-29 09:38:08,340 - __main__ - INFO - Processing values: 2018-01-26 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,379 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 15 hr time horizon... +2026-04-29 09:38:08,406 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,495 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 14 hr time horizon... +2026-04-29 09:38:08,512 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 9 hr time horizon... +2026-04-29 09:38:08,545 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 15 hr time horizon... +2026-04-29 09:38:08,569 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,956 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:08,978 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:10,352 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 9 hr time horizon... +2026-04-29 09:38:10,376 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:10,516 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 10 hr time horizon... +2026-04-29 09:38:10,540 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:11,881 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 7 hr time horizon... +2026-04-29 09:38:11,904 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:12,156 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 12 hr time horizon... +2026-04-29 09:38:12,180 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:13,549 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 5 hr time horizon... +2026-04-29 09:38:13,579 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:14,193 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 11 hr time horizon... +2026-04-29 09:38:14,216 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:14,466 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 12 hr time horizon... +2026-04-29 09:38:14,486 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:15,013 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 4 hr time horizon... +2026-04-29 09:38:15,038 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:17,194 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 14 hr time horizon... +2026-04-29 09:38:17,217 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:18,295 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 16 hr time horizon... +2026-04-29 09:38:18,319 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:22,158 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 6 hr time horizon... +2026-04-29 09:38:22,182 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:22,448 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 3 hr time horizon... +2026-04-29 09:38:22,474 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:22,660 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 17 hr time horizon... +2026-04-29 09:38:22,689 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:38:22,830 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:22,855 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:23,402 - __main__ - INFO - Finished processing 2018-01-26 15:00:00 17 hr time horizon... +2026-04-29 09:38:23,426 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:23,961 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 9 hr time horizon... +2026-04-29 09:38:23,987 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:24,155 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:24,183 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:24,713 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 15 hr time horizon... +2026-04-29 09:38:24,733 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:24,771 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 6 hr time horizon... +2026-04-29 09:38:24,793 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:25,199 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 8 hr time horizon... +2026-04-29 09:38:25,226 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:26,186 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 15 hr time horizon... +2026-04-29 09:38:26,227 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:28,190 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 2 hr time horizon... +2026-04-29 09:38:28,215 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:28,466 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 18 hr time horizon... +2026-04-29 09:38:28,487 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:28,633 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:28,674 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:29,898 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 10 hr time horizon... +2026-04-29 09:38:29,923 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:30,370 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 9 hr time horizon... +2026-04-29 09:38:30,392 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 1 hr time horizon... +2026-04-29 09:38:30,503 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 16 hr time horizon... +2026-04-29 09:38:30,524 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:32,671 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 8 hr time horizon... +2026-04-29 09:38:32,692 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:33,895 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 16 hr time horizon... +2026-04-29 09:38:33,915 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:36,410 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:36,438 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:36,935 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:36,959 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:37,022 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:37,042 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:37,679 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 3 hr time horizon... +2026-04-29 09:38:37,699 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:37,835 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:37,856 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:38,454 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 2 hr time horizon... +2026-04-29 09:38:38,473 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:38,727 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 11 hr time horizon... +2026-04-29 09:38:38,750 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:39,983 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 7 hr time horizon... +2026-04-29 09:38:40,010 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 15 hr time horizon... +2026-04-29 09:38:40,016 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 12 hr time horizon... +2026-04-29 09:38:40,039 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:38:40,828 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:40,854 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 5 hr time horizon... +2026-04-29 09:38:40,962 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 16 hr time horizon... +2026-04-29 09:38:40,989 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:43,025 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 15 hr time horizon... +2026-04-29 09:38:43,051 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:43,601 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 1 hr time horizon... +2026-04-29 09:38:43,621 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:44,867 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 7 hr time horizon... +2026-04-29 09:38:44,889 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:45,380 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 15 hr time horizon... +2026-04-29 09:38:45,400 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 7 hr time horizon... +2026-04-29 09:38:45,431 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 1 hr time horizon... +2026-04-29 09:38:45,450 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:47,508 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 2 hr time horizon... +2026-04-29 09:38:47,536 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:48,185 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 3 hr time horizon... +2026-04-29 09:38:48,204 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:48,781 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 9 hr time horizon... +2026-04-29 09:38:48,802 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:50,157 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 1 hr time horizon... +2026-04-29 09:38:50,178 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:50,946 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 7 hr time horizon... +2026-04-29 09:38:50,970 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:51,120 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 10 hr time horizon... +2026-04-29 09:38:51,143 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:51,959 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:51,981 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:52,813 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 4 hr time horizon... +2026-04-29 09:38:52,837 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 9 hr time horizon... +2026-04-29 09:38:52,917 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 7 hr time horizon... +2026-04-29 09:38:52,939 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:53,771 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 13 hr time horizon... +2026-04-29 09:38:53,792 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:54,734 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 15 hr time horizon... +2026-04-29 09:38:54,760 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:56,205 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 5 hr time horizon... +2026-04-29 09:38:56,225 - __main__ - INFO - Processing values: 2018-01-09 06:00:00 4 hr time horizon... +2026-04-29 09:38:56,303 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 5 hr time horizon... +2026-04-29 09:38:56,325 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:57,740 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:57,762 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:58,339 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 18 hr time horizon... +2026-04-29 09:38:58,362 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:38:59,149 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 8 hr time horizon... +2026-04-29 09:38:59,177 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:00,263 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 15 hr time horizon... +2026-04-29 09:39:00,289 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:01,303 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 15 hr time horizon... +2026-04-29 09:39:01,312 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 7 hr time horizon... +2026-04-29 09:39:01,337 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 6 hr time horizon... +2026-04-29 09:39:01,345 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:02,697 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:02,720 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:03,473 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 13 hr time horizon... +2026-04-29 09:39:03,498 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:03,723 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 8 hr time horizon... +2026-04-29 09:39:03,744 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:04,320 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 1 hr time horizon... +2026-04-29 09:39:04,345 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:06,254 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:06,281 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:06,460 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:06,485 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:07,759 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 9 hr time horizon... +2026-04-29 09:39:07,789 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:07,920 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 13 hr time horizon... +2026-04-29 09:39:07,944 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:08,414 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 2 hr time horizon... +2026-04-29 09:39:08,445 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 5 hr time horizon... +2026-04-29 09:39:08,664 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 8 hr time horizon... +2026-04-29 09:39:08,686 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:08,873 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 16 hr time horizon... +2026-04-29 09:39:08,901 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:11,263 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 12 hr time horizon... +2026-04-29 09:39:11,284 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:12,270 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 5 hr time horizon... +2026-04-29 09:39:12,293 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:12,761 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:12,785 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:13,842 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 7 hr time horizon... +2026-04-29 09:39:13,866 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:15,326 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 14 hr time horizon... +2026-04-29 09:39:15,349 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:15,724 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 5 hr time horizon... +2026-04-29 09:39:15,747 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 3 hr time horizon... +2026-04-29 09:39:15,837 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 6 hr time horizon... +2026-04-29 09:39:15,859 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:18,328 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 9 hr time horizon... +2026-04-29 09:39:18,350 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:18,548 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 11 hr time horizon... +2026-04-29 09:39:18,570 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:18,894 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 9 hr time horizon... +2026-04-29 09:39:18,920 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 12 hr time horizon... +2026-04-29 09:39:19,019 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 12 hr time horizon... +2026-04-29 09:39:19,046 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:21,595 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 12 hr time horizon... +2026-04-29 09:39:21,633 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:22,265 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:22,289 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:23,422 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 11 hr time horizon... +2026-04-29 09:39:23,443 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:23,899 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 17 hr time horizon... +2026-04-29 09:39:23,925 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:24,193 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 8 hr time horizon... +2026-04-29 09:39:24,216 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 8 hr time horizon... +2026-04-29 09:39:24,316 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 5 hr time horizon... +2026-04-29 09:39:24,342 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:24,471 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 14 hr time horizon... +2026-04-29 09:39:24,491 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:24,810 - __main__ - INFO - Finished processing 2018-01-09 06:00:00 4 hr time horizon... +2026-04-29 09:39:24,834 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:26,899 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:26,920 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:28,207 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 8 hr time horizon... +2026-04-29 09:39:28,232 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 1 hr time horizon... +2026-04-29 09:39:28,331 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 1 hr time horizon... +2026-04-29 09:39:28,354 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:29,098 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:29,128 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:31,482 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:31,503 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:31,685 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 8 hr time horizon... +2026-04-29 09:39:31,708 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 4 hr time horizon... +2026-04-29 09:39:31,771 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:31,796 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:32,520 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 1 hr time horizon... +2026-04-29 09:39:32,538 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:33,957 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 17 hr time horizon... +2026-04-29 09:39:33,978 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:34,209 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 12 hr time horizon... +2026-04-29 09:39:34,228 - __main__ - INFO - Processing values: 2018-01-11 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:35,174 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 12 hr time horizon... +2026-04-29 09:39:35,194 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:36,714 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 16 hr time horizon... +2026-04-29 09:39:36,734 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:38,390 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 18 hr time horizon... +2026-04-29 09:39:38,425 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:38,950 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 5 hr time horizon... +2026-04-29 09:39:38,971 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:39,098 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 4 hr time horizon... +2026-04-29 09:39:39,117 - __main__ - INFO - Processing values: 2018-01-16 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:39,428 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:39,452 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:39,991 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 8 hr time horizon... +2026-04-29 09:39:40,016 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 11 hr time horizon... +2026-04-29 09:39:40,050 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 5 hr time horizon... +2026-04-29 09:39:40,084 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:40,691 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:40,714 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:42,358 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 13 hr time horizon... +2026-04-29 09:39:42,381 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:42,932 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 1 hr time horizon... +2026-04-29 09:39:42,953 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 12 hr time horizon... +2026-04-29 09:39:43,151 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 10 hr time horizon... +2026-04-29 09:39:43,172 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:44,957 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 4 hr time horizon... +2026-04-29 09:39:44,975 - __main__ - INFO - Processing values: 2018-01-19 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:46,541 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 9 hr time horizon... +2026-04-29 09:39:46,563 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:46,841 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 4 hr time horizon... +2026-04-29 09:39:46,868 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:47,130 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 12 hr time horizon... +2026-04-29 09:39:47,151 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:48,490 - __main__ - INFO - Finished processing 2018-01-11 13:00:00 6 hr time horizon... +2026-04-29 09:39:48,517 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:49,075 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 17 hr time horizon... +2026-04-29 09:39:49,098 - __main__ - INFO - Processing values: 2018-01-26 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:49,941 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 9 hr time horizon... +2026-04-29 09:39:49,971 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:50,375 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 6 hr time horizon... +2026-04-29 09:39:50,394 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:50,926 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 6 hr time horizon... +2026-04-29 09:39:50,946 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:53,304 - __main__ - INFO - Finished processing 2018-01-16 11:00:00 7 hr time horizon... +2026-04-29 09:39:53,328 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:53,418 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 15 hr time horizon... +2026-04-29 09:39:53,441 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 15 hr time horizon... +2026-04-29 09:39:53,487 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 8 hr time horizon... +2026-04-29 09:39:53,509 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:53,696 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 1 hr time horizon... +2026-04-29 09:39:53,719 - __main__ - INFO - Processing values: 2018-01-21 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:54,225 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 11 hr time horizon... +2026-04-29 09:39:54,245 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:54,675 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 2 hr time horizon... +2026-04-29 09:39:54,703 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:54,925 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 6 hr time horizon... +2026-04-29 09:39:54,946 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:57,158 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:57,178 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 10 hr time horizon... +2026-04-29 09:39:57,235 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 14 hr time horizon... +2026-04-29 09:39:57,257 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:39:57,787 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 18 hr time horizon... +2026-04-29 09:39:57,806 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:00,016 - __main__ - INFO - Finished processing 2018-01-19 05:00:00 13 hr time horizon... +2026-04-29 09:40:00,041 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:00,625 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 15 hr time horizon... +2026-04-29 09:40:00,647 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:01,179 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 10 hr time horizon... +2026-04-29 09:40:01,197 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:02,060 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 2 hr time horizon... +2026-04-29 09:40:02,080 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:03,045 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 17 hr time horizon... +2026-04-29 09:40:03,066 - __main__ - INFO - Processing values: 2018-01-04 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:03,791 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 4 hr time horizon... +2026-04-29 09:40:03,809 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:04,250 - __main__ - INFO - Finished processing 2018-01-26 16:00:00 1 hr time horizon... +2026-04-29 09:40:04,270 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:04,757 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 9 hr time horizon... +2026-04-29 09:40:04,779 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:05,093 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 1 hr time horizon... +2026-04-29 09:40:05,115 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:07,965 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:07,972 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 14 hr time horizon... +2026-04-29 09:40:07,994 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 3 hr time horizon... +2026-04-29 09:40:08,001 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:08,637 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 15 hr time horizon... +2026-04-29 09:40:08,662 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:08,872 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 8 hr time horizon... +2026-04-29 09:40:08,892 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:10,120 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 5 hr time horizon... +2026-04-29 09:40:10,136 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 8 hr time horizon... +2026-04-29 09:40:10,142 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 3 hr time horizon... +2026-04-29 09:40:10,159 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:10,340 - __main__ - INFO - Finished processing 2018-01-21 19:00:00 12 hr time horizon... +2026-04-29 09:40:10,363 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:12,385 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 10 hr time horizon... +2026-04-29 09:40:12,408 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:12,987 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 10 hr time horizon... +2026-04-29 09:40:13,016 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:13,309 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 16 hr time horizon... +2026-04-29 09:40:13,336 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:15,565 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 10 hr time horizon... +2026-04-29 09:40:15,581 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 6 hr time horizon... +2026-04-29 09:40:15,591 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 17 hr time horizon... +2026-04-29 09:40:15,606 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:15,768 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 1 hr time horizon... +2026-04-29 09:40:15,788 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:17,066 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 17 hr time horizon... +2026-04-29 09:40:17,087 - __main__ - INFO - Processing values: 2018-01-10 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:18,080 - __main__ - INFO - Finished processing 2018-01-04 13:00:00 6 hr time horizon... +2026-04-29 09:40:18,100 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:19,965 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 17 hr time horizon... +2026-04-29 09:40:19,988 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 10 hr time horizon... +2026-04-29 09:40:20,201 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 8 hr time horizon... +2026-04-29 09:40:20,222 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:20,379 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:20,402 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:21,029 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 15 hr time horizon... +2026-04-29 09:40:21,053 - __main__ - INFO - Processing values: 2018-01-14 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:23,244 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 12 hr time horizon... +2026-04-29 09:40:23,270 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:23,388 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 7 hr time horizon... +2026-04-29 09:40:23,412 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:23,453 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 3 hr time horizon... +2026-04-29 09:40:23,476 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:24,365 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 7 hr time horizon... +2026-04-29 09:40:24,389 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:25,369 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 10 hr time horizon... +2026-04-29 09:40:25,389 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 4 hr time horizon... +2026-04-29 09:40:25,544 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:25,572 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:25,967 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 2 hr time horizon... +2026-04-29 09:40:25,999 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:27,694 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 11 hr time horizon... +2026-04-29 09:40:27,717 - __main__ - INFO - Processing values: 2018-01-24 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:28,628 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 10 hr time horizon... +2026-04-29 09:40:28,655 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 10 hr time horizon... +2026-04-29 09:40:28,671 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:28,696 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:30,875 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 17 hr time horizon... +2026-04-29 09:40:30,898 - __main__ - INFO - Processing values: 2018-01-11 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:31,320 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:31,346 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:31,795 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 17 hr time horizon... +2026-04-29 09:40:31,817 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:33,117 - __main__ - INFO - Finished processing 2018-01-10 11:00:00 16 hr time horizon... +2026-04-29 09:40:33,144 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:33,947 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:33,968 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:35,177 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:35,200 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:35,941 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:35,979 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:36,342 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 10 hr time horizon... +2026-04-29 09:40:36,371 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:37,019 - __main__ - INFO - Finished processing 2018-01-14 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:37,044 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:37,814 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 3 hr time horizon... +2026-04-29 09:40:37,841 - __main__ - INFO - Processing values: 2018-01-28 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:38,854 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:38,878 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:39,151 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:39,178 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 17 hr time horizon... +2026-04-29 09:40:39,185 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 4 hr time horizon... +2026-04-29 09:40:39,206 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:40,837 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 15 hr time horizon... +2026-04-29 09:40:40,864 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:41,489 - __main__ - INFO - Finished processing 2018-01-24 08:00:00 1 hr time horizon... +2026-04-29 09:40:41,510 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:41,838 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 18 hr time horizon... +2026-04-29 09:40:41,861 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 15 hr time horizon... +2026-04-29 09:40:42,068 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 4 hr time horizon... +2026-04-29 09:40:42,093 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:43,137 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 1 hr time horizon... +2026-04-29 09:40:43,156 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:45,749 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 10 hr time horizon... +2026-04-29 09:40:45,775 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:45,970 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 3 hr time horizon... +2026-04-29 09:40:45,993 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:46,184 - __main__ - INFO - Finished processing 2018-01-11 15:00:00 14 hr time horizon... +2026-04-29 09:40:46,220 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:46,923 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 3 hr time horizon... +2026-04-29 09:40:46,942 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:47,861 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 5 hr time horizon... +2026-04-29 09:40:47,882 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:49,025 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:49,056 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:50,929 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 13 hr time horizon... +2026-04-29 09:40:50,951 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 14 hr time horizon... +2026-04-29 09:40:50,965 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 11 hr time horizon... +2026-04-29 09:40:50,987 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:51,491 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 14 hr time horizon... +2026-04-29 09:40:51,517 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:52,263 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:52,284 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:53,273 - __main__ - INFO - Finished processing 2018-01-28 02:00:00 4 hr time horizon... +2026-04-29 09:40:53,300 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:54,722 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:54,746 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 18 hr time horizon... +2026-04-29 09:40:54,810 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:54,837 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:55,522 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 7 hr time horizon... +2026-04-29 09:40:55,546 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:40:56,357 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:56,378 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:56,982 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 16 hr time horizon... +2026-04-29 09:40:57,007 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:57,227 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 15 hr time horizon... +2026-04-29 09:40:57,248 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:57,644 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 16 hr time horizon... +2026-04-29 09:40:57,667 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:40:58,160 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 3 hr time horizon... +2026-04-29 09:40:58,185 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:00,783 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 10 hr time horizon... +2026-04-29 09:41:00,800 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:01,099 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:01,122 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:01,306 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 16 hr time horizon... +2026-04-29 09:41:01,327 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:01,708 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 11 hr time horizon... +2026-04-29 09:41:01,727 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:01,951 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 12 hr time horizon... +2026-04-29 09:41:01,973 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:04,009 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 7 hr time horizon... +2026-04-29 09:41:04,030 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:04,832 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 14 hr time horizon... +2026-04-29 09:41:04,857 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:05,319 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 10 hr time horizon... +2026-04-29 09:41:05,339 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:05,469 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 4 hr time horizon... +2026-04-29 09:41:05,499 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:07,901 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:07,934 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:08,571 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 10 hr time horizon... +2026-04-29 09:41:08,593 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:08,775 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 18 hr time horizon... +2026-04-29 09:41:08,796 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:09,138 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 5 hr time horizon... +2026-04-29 09:41:09,163 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:09,986 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:10,011 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:10,908 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 1 hr time horizon... +2026-04-29 09:41:10,929 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:11,950 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 10 hr time horizon... +2026-04-29 09:41:11,970 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:12,866 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 6 hr time horizon... +2026-04-29 09:41:12,889 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:13,820 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 12 hr time horizon... +2026-04-29 09:41:13,843 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:16,266 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 8 hr time horizon... +2026-04-29 09:41:16,289 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 3 hr time horizon... +2026-04-29 09:41:16,431 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 4 hr time horizon... +2026-04-29 09:41:16,465 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 4 hr time horizon... +2026-04-29 09:41:16,504 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:16,524 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 5 hr time horizon... +2026-04-29 09:41:16,574 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 17 hr time horizon... +2026-04-29 09:41:16,598 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:17,474 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 13 hr time horizon... +2026-04-29 09:41:17,502 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:20,048 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 3 hr time horizon... +2026-04-29 09:41:20,068 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:20,374 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 2 hr time horizon... +2026-04-29 09:41:20,394 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:20,657 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:20,680 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:22,291 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 6 hr time horizon... +2026-04-29 09:41:22,313 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:22,697 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 2 hr time horizon... +2026-04-29 09:41:22,718 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:23,222 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:23,248 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:23,568 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 11 hr time horizon... +2026-04-29 09:41:23,596 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:24,161 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 7 hr time horizon... +2026-04-29 09:41:24,184 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:24,248 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 15 hr time horizon... +2026-04-29 09:41:24,268 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:24,772 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 5 hr time horizon... +2026-04-29 09:41:24,792 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:25,221 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 1 hr time horizon... +2026-04-29 09:41:25,242 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:26,496 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 18 hr time horizon... +2026-04-29 09:41:26,518 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:28,549 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 10 hr time horizon... +2026-04-29 09:41:28,571 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:28,716 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 17 hr time horizon... +2026-04-29 09:41:28,738 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:30,424 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 5 hr time horizon... +2026-04-29 09:41:30,445 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:30,476 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 3 hr time horizon... +2026-04-29 09:41:30,495 - __main__ - INFO - Processing values: 2018-01-11 13:00:00 11 hr time horizon... +2026-04-29 09:41:30,647 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:30,670 - __main__ - INFO - Processing values: 2018-01-09 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:31,261 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 12 hr time horizon... +2026-04-29 09:41:31,283 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 8 hr time horizon... +2026-04-29 09:41:31,398 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 4 hr time horizon... +2026-04-29 09:41:31,416 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:35,015 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 12 hr time horizon... +2026-04-29 09:41:35,052 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:35,526 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:35,547 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:36,039 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 4 hr time horizon... +2026-04-29 09:41:36,058 - __main__ - INFO - Processing values: 2018-01-15 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:36,267 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 6 hr time horizon... +2026-04-29 09:41:36,287 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:37,557 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 11 hr time horizon... +2026-04-29 09:41:37,578 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:37,673 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 8 hr time horizon... +2026-04-29 09:41:37,694 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:38,116 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 4 hr time horizon... +2026-04-29 09:41:38,149 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:38,232 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 14 hr time horizon... +2026-04-29 09:41:38,256 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:40,446 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 5 hr time horizon... +2026-04-29 09:41:40,467 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 9 hr time horizon... +2026-04-29 09:41:40,685 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 5 hr time horizon... +2026-04-29 09:41:40,712 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:40,784 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 10 hr time horizon... +2026-04-29 09:41:40,804 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:42,528 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:42,551 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:45,256 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 18 hr time horizon... +2026-04-29 09:41:45,283 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:45,357 - __main__ - INFO - Finished processing 2018-01-11 13:00:00 11 hr time horizon... +2026-04-29 09:41:45,386 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 12 hr time horizon... +2026-04-29 09:41:45,411 - __main__ - INFO - Finished processing 2018-01-09 16:00:00 11 hr time horizon... +2026-04-29 09:41:45,440 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:45,501 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 5 hr time horizon... +2026-04-29 09:41:45,519 - __main__ - INFO - Processing values: 2018-01-08 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:46,069 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 8 hr time horizon... +2026-04-29 09:41:46,091 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 14 hr time horizon... +2026-04-29 09:41:46,223 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 15 hr time horizon... +2026-04-29 09:41:46,243 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:49,678 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:41:49,711 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:50,319 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 3 hr time horizon... +2026-04-29 09:41:50,339 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:50,590 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 11 hr time horizon... +2026-04-29 09:41:50,614 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:51,091 - __main__ - INFO - Finished processing 2018-01-15 17:00:00 12 hr time horizon... +2026-04-29 09:41:51,114 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:51,420 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 1 hr time horizon... +2026-04-29 09:41:51,443 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:52,751 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 17 hr time horizon... +2026-04-29 09:41:52,771 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:52,878 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 7 hr time horizon... +2026-04-29 09:41:52,898 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:53,664 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:53,685 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:54,672 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 1 hr time horizon... +2026-04-29 09:41:54,695 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:56,468 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 9 hr time horizon... +2026-04-29 09:41:56,494 - __main__ - INFO - Processing values: 2018-01-05 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:56,611 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 2 hr time horizon... +2026-04-29 09:41:56,630 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:57,582 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 17 hr time horizon... +2026-04-29 09:41:57,608 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:41:58,609 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 2 hr time horizon... +2026-04-29 09:41:58,629 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:01,346 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 12 hr time horizon... +2026-04-29 09:42:01,367 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 12 hr time horizon... +2026-04-29 09:42:01,389 - __main__ - INFO - Finished processing 2018-01-08 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:01,426 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 17 hr time horizon... +2026-04-29 09:42:01,480 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 1 hr time horizon... +2026-04-29 09:42:01,504 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:01,554 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 14 hr time horizon... +2026-04-29 09:42:01,575 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:03,938 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 1 hr time horizon... +2026-04-29 09:42:03,958 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:04,533 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 13 hr time horizon... +2026-04-29 09:42:04,560 - __main__ - INFO - Processing values: 2018-01-28 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:04,925 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 13 hr time horizon... +2026-04-29 09:42:04,947 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:05,613 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 2 hr time horizon... +2026-04-29 09:42:05,635 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:05,854 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:05,879 - __main__ - INFO - Processing values: 2018-01-20 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:06,327 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 15 hr time horizon... +2026-04-29 09:42:06,349 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:06,597 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 1 hr time horizon... +2026-04-29 09:42:06,615 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:07,074 - __main__ - INFO - No valid message found: PosixPath('/home/kperry/data/hrrr/20180126/subset_3569165b__hrrr.t10z.wrfprsf17.grib2') +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:07,652 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 9 hr time horizon... +2026-04-29 09:42:07,671 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:08,610 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:08,634 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 11 hr time horizon... +2026-04-29 09:42:08,679 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 14 hr time horizon... +2026-04-29 09:42:08,699 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:09,252 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 7 hr time horizon... +2026-04-29 09:42:09,273 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:10,732 - __main__ - INFO - Finished processing 2018-01-05 02:00:00 5 hr time horizon... +2026-04-29 09:42:10,753 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:11,265 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 9 hr time horizon... +2026-04-29 09:42:11,285 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:11,998 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 7 hr time horizon... +2026-04-29 09:42:12,015 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 1 hr time horizon... +2026-04-29 09:42:12,074 - __main__ - INFO - Download failed for {date} {time_horizon} hr time horizon... +2026-04-29 09:42:12,075 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:12,542 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 14 hr time horizon... +2026-04-29 09:42:12,563 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:14,955 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 12 hr time horizon... +2026-04-29 09:42:14,976 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:15,645 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 12 hr time horizon... +2026-04-29 09:42:15,668 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:15,856 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 17 hr time horizon... +2026-04-29 09:42:15,882 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:16,401 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 17 hr time horizon... +2026-04-29 09:42:16,427 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:18,025 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 14 hr time horizon... +2026-04-29 09:42:18,048 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:19,141 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 5 hr time horizon... +2026-04-29 09:42:19,165 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:19,377 - __main__ - INFO - Finished processing 2018-01-28 02:00:00 11 hr time horizon... +2026-04-29 09:42:19,412 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:19,668 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 2 hr time horizon... +2026-04-29 09:42:19,693 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:20,531 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 9 hr time horizon... +2026-04-29 09:42:20,549 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:20,811 - __main__ - INFO - Finished processing 2018-01-20 22:00:00 2 hr time horizon... +2026-04-29 09:42:20,832 - __main__ - INFO - Processing values: 2018-01-26 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:22,176 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 3 hr time horizon... +2026-04-29 09:42:22,197 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:23,394 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 2 hr time horizon... +2026-04-29 09:42:23,418 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:24,320 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 10 hr time horizon... +2026-04-29 09:42:24,342 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:25,780 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 16 hr time horizon... +2026-04-29 09:42:25,808 - __main__ - INFO - Processing values: 2018-01-07 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:26,109 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 17 hr time horizon... +2026-04-29 09:42:26,131 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:27,093 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:27,116 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 6 hr time horizon... +2026-04-29 09:42:27,152 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 11 hr time horizon... +2026-04-29 09:42:27,176 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 11 hr time horizon... +2026-04-29 09:42:27,411 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 14 hr time horizon... +2026-04-29 09:42:27,435 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:28,862 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 15 hr time horizon... +2026-04-29 09:42:28,891 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:30,550 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 11 hr time horizon... +2026-04-29 09:42:30,572 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:31,467 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 1 hr time horizon... +2026-04-29 09:42:31,489 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:31,817 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:31,846 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:32,484 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 5 hr time horizon... +2026-04-29 09:42:32,519 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:33,616 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 18 hr time horizon... +2026-04-29 09:42:33,641 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:34,831 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 5 hr time horizon... +2026-04-29 09:42:34,863 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:35,378 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 17 hr time horizon... +2026-04-29 09:42:35,401 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 12 hr time horizon... +2026-04-29 09:42:35,494 - __main__ - INFO - Finished processing 2018-01-26 21:00:00 3 hr time horizon... +2026-04-29 09:42:35,518 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:35,669 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 17 hr time horizon... +2026-04-29 09:42:35,691 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:37,246 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 18 hr time horizon... +2026-04-29 09:42:37,267 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:38,651 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 9 hr time horizon... +2026-04-29 09:42:38,672 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:40,165 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 7 hr time horizon... +2026-04-29 09:42:40,186 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:40,576 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 11 hr time horizon... +2026-04-29 09:42:40,595 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:41,208 - __main__ - INFO - Finished processing 2018-01-07 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:41,235 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:41,687 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 8 hr time horizon... +2026-04-29 09:42:41,712 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:41,992 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 6 hr time horizon... +2026-04-29 09:42:42,012 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:42,214 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 11 hr time horizon... +2026-04-29 09:42:42,239 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:42,998 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 10 hr time horizon... +2026-04-29 09:42:43,020 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:43,384 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 4 hr time horizon... +2026-04-29 09:42:43,404 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:46,142 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:46,165 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:46,801 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 16 hr time horizon... +2026-04-29 09:42:46,829 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:47,514 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 8 hr time horizon... +2026-04-29 09:42:47,534 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:47,652 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:47,675 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:48,642 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 16 hr time horizon... +2026-04-29 09:42:48,664 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:49,454 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 12 hr time horizon... +2026-04-29 09:42:49,478 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:49,564 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:49,593 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:50,128 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 5 hr time horizon... +2026-04-29 09:42:50,148 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:50,661 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 8 hr time horizon... +2026-04-29 09:42:50,679 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:51,882 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 11 hr time horizon... +2026-04-29 09:42:51,903 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:53,707 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:53,738 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:55,899 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 17 hr time horizon... +2026-04-29 09:42:55,924 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:42:56,694 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:56,719 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 15 hr time horizon... +2026-04-29 09:42:56,814 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 5 hr time horizon... +2026-04-29 09:42:56,833 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:59,598 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:42:59,618 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:00,133 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 11 hr time horizon... +2026-04-29 09:43:00,150 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:00,691 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:00,711 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 18 hr time horizon... +2026-04-29 09:43:00,812 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 5 hr time horizon... +2026-04-29 09:43:00,831 - __main__ - INFO - Processing values: 2018-01-21 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:00,955 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 6 hr time horizon... +2026-04-29 09:43:00,977 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:01,618 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 12 hr time horizon... +2026-04-29 09:43:01,638 - __main__ - INFO - Processing values: 2018-01-05 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:03,262 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:03,284 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:03,909 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 7 hr time horizon... +2026-04-29 09:43:03,936 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:43:04,461 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:04,486 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:05,576 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 14 hr time horizon... +2026-04-29 09:43:05,602 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:06,467 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 1 hr time horizon... +2026-04-29 09:43:06,489 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:08,338 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 13 hr time horizon... +2026-04-29 09:43:08,360 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:09,726 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 16 hr time horizon... +2026-04-29 09:43:09,746 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:10,187 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 15 hr time horizon... +2026-04-29 09:43:10,209 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:12,902 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 3 hr time horizon... +2026-04-29 09:43:12,922 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:13,057 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 12 hr time horizon... +2026-04-29 09:43:13,083 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:13,582 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 18 hr time horizon... +2026-04-29 09:43:13,602 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:13,955 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 1 hr time horizon... +2026-04-29 09:43:13,977 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:14,553 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 4 hr time horizon... +2026-04-29 09:43:14,573 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:14,911 - __main__ - INFO - Finished processing 2018-01-05 07:00:00 13 hr time horizon... +2026-04-29 09:43:14,935 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:15,842 - __main__ - INFO - Finished processing 2018-01-21 06:00:00 13 hr time horizon... +2026-04-29 09:43:15,865 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:17,363 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 11 hr time horizon... +2026-04-29 09:43:17,390 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:17,661 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 3 hr time horizon... +2026-04-29 09:43:17,685 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:17,937 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:17,960 - __main__ - INFO - Processing values: 2018-01-11 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:19,774 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 7 hr time horizon... +2026-04-29 09:43:19,797 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:20,275 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 11 hr time horizon... +2026-04-29 09:43:20,300 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:20,852 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 7 hr time horizon... +2026-04-29 09:43:20,878 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:43:21,950 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:21,982 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:22,462 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 6 hr time horizon... +2026-04-29 09:43:22,487 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:22,606 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 14 hr time horizon... +2026-04-29 09:43:22,628 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:24,860 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 3 hr time horizon... +2026-04-29 09:43:24,880 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:25,123 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 16 hr time horizon... +2026-04-29 09:43:25,147 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:26,793 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 9 hr time horizon... +2026-04-29 09:43:26,817 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:27,021 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:27,045 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:27,755 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 13 hr time horizon... +2026-04-29 09:43:27,797 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:29,334 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:29,359 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:29,472 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 18 hr time horizon... +2026-04-29 09:43:29,497 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:30,822 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 17 hr time horizon... +2026-04-29 09:43:30,853 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:31,022 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 15 hr time horizon... +2026-04-29 09:43:31,045 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:31,685 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:31,706 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:32,265 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 13 hr time horizon... +2026-04-29 09:43:32,287 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:33,144 - __main__ - INFO - Finished processing 2018-01-11 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:33,168 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:34,578 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 7 hr time horizon... +2026-04-29 09:43:34,598 - __main__ - INFO - Processing values: 2018-01-27 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:35,054 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:35,079 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:35,624 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 15 hr time horizon... +2026-04-29 09:43:35,645 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:35,879 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 14 hr time horizon... +2026-04-29 09:43:35,900 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:36,810 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 14 hr time horizon... +2026-04-29 09:43:36,830 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:37,533 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:37,555 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:37,613 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 2 hr time horizon... +2026-04-29 09:43:37,636 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:39,558 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 7 hr time horizon... +2026-04-29 09:43:39,579 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 12 hr time horizon... +2026-04-29 09:43:39,603 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:39,626 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:41,062 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 13 hr time horizon... +2026-04-29 09:43:41,080 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:42,347 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 18 hr time horizon... +2026-04-29 09:43:42,372 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:43,780 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 3 hr time horizon... +2026-04-29 09:43:43,800 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:44,811 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 2 hr time horizon... +2026-04-29 09:43:44,832 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 18 hr time horizon... +2026-04-29 09:43:44,914 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:44,933 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:45,547 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:45,576 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:45,777 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 13 hr time horizon... +2026-04-29 09:43:45,800 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:48,094 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:48,115 - __main__ - INFO - Processing values: 2018-01-09 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:48,371 - __main__ - INFO - Finished processing 2018-01-14 21:00:00 3 hr time horizon... +2026-04-29 09:43:48,390 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:48,885 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 5 hr time horizon... +2026-04-29 09:43:48,908 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:49,643 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 14 hr time horizon... +2026-04-29 09:43:49,668 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:51,012 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 14 hr time horizon... +2026-04-29 09:43:51,031 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:51,472 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 3 hr time horizon... +2026-04-29 09:43:51,491 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:52,001 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 16 hr time horizon... +2026-04-29 09:43:52,025 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:52,751 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 12 hr time horizon... +2026-04-29 09:43:52,773 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:56,115 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 13 hr time horizon... +2026-04-29 09:43:56,138 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:57,130 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 5 hr time horizon... +2026-04-29 09:43:57,153 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:57,562 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 16 hr time horizon... +2026-04-29 09:43:57,584 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:58,079 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 4 hr time horizon... +2026-04-29 09:43:58,106 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:58,585 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:58,615 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:43:59,468 - __main__ - INFO - Finished processing 2018-01-27 01:00:00 6 hr time horizon... +2026-04-29 09:43:59,491 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:00,153 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 7 hr time horizon... +2026-04-29 09:44:00,178 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:00,422 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 5 hr time horizon... +2026-04-29 09:44:00,445 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:01,464 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 13 hr time horizon... +2026-04-29 09:44:01,484 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:02,457 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 6 hr time horizon... +2026-04-29 09:44:02,481 - __main__ - INFO - Processing values: 2018-01-26 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:02,654 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 4 hr time horizon... +2026-04-29 09:44:02,679 - __main__ - INFO - Processing values: 2018-01-05 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:02,876 - __main__ - INFO - Finished processing 2018-01-09 06:00:00 9 hr time horizon... +2026-04-29 09:44:02,901 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:04,253 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:04,277 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:04,898 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 10 hr time horizon... +2026-04-29 09:44:04,923 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:05,506 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 6 hr time horizon... +2026-04-29 09:44:05,527 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:06,404 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 17 hr time horizon... +2026-04-29 09:44:06,427 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:07,177 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 2 hr time horizon... +2026-04-29 09:44:07,197 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:08,138 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 6 hr time horizon... +2026-04-29 09:44:08,159 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:11,482 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:11,501 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:11,896 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 4 hr time horizon... +2026-04-29 09:44:11,915 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 9 hr time horizon... +2026-04-29 09:44:12,107 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 10 hr time horizon... +2026-04-29 09:44:12,128 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:12,284 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 2 hr time horizon... +2026-04-29 09:44:12,309 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:12,821 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 3 hr time horizon... +2026-04-29 09:44:12,838 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:14,742 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:14,766 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:15,393 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 14 hr time horizon... +2026-04-29 09:44:15,416 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:15,537 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 12 hr time horizon... +2026-04-29 09:44:15,559 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:16,681 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 1 hr time horizon... +2026-04-29 09:44:16,700 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:17,180 - __main__ - INFO - Finished processing 2018-01-26 16:00:00 3 hr time horizon... +2026-04-29 09:44:17,203 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:17,350 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:17,375 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:17,996 - __main__ - INFO - Finished processing 2018-01-05 02:00:00 18 hr time horizon... +2026-04-29 09:44:18,021 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:18,908 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 18 hr time horizon... +2026-04-29 09:44:18,933 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:19,871 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 11 hr time horizon... +2026-04-29 09:44:19,891 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 17 hr time horizon... +2026-04-29 09:44:19,906 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 2 hr time horizon... +2026-04-29 09:44:19,926 - __main__ - INFO - Processing values: 2018-01-14 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:20,463 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 7 hr time horizon... +2026-04-29 09:44:20,485 - __main__ - INFO - Processing values: 2018-01-22 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:22,466 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 13 hr time horizon... +2026-04-29 09:44:22,486 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:23,801 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 8 hr time horizon... +2026-04-29 09:44:23,826 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:26,777 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 9 hr time horizon... +2026-04-29 09:44:26,804 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 5 hr time horizon... +2026-04-29 09:44:26,862 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 1 hr time horizon... +2026-04-29 09:44:26,883 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:26,957 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 6 hr time horizon... +2026-04-29 09:44:26,981 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:27,028 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 17 hr time horizon... +2026-04-29 09:44:27,051 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:27,941 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 1 hr time horizon... +2026-04-29 09:44:27,962 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:29,721 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 10 hr time horizon... +2026-04-29 09:44:29,742 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:29,965 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 15 hr time horizon... +2026-04-29 09:44:29,987 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:30,870 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 4 hr time horizon... +2026-04-29 09:44:30,893 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:31,863 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 11 hr time horizon... +2026-04-29 09:44:31,887 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:31,950 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 9 hr time horizon... +2026-04-29 09:44:31,975 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 12 hr time horizon... +2026-04-29 09:44:31,977 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:32,006 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:33,250 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 6 hr time horizon... +2026-04-29 09:44:33,273 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:33,735 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 4 hr time horizon... +2026-04-29 09:44:33,756 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:33,918 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 16 hr time horizon... +2026-04-29 09:44:33,943 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:34,216 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:34,237 - __main__ - INFO - Processing values: 2018-01-04 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:34,678 - __main__ - INFO - Finished processing 2018-01-14 09:00:00 15 hr time horizon... +2026-04-29 09:44:34,699 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:35,532 - __main__ - INFO - Finished processing 2018-01-22 12:00:00 10 hr time horizon... +2026-04-29 09:44:35,552 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:37,362 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 1 hr time horizon... +2026-04-29 09:44:37,379 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 13 hr time horizon... +2026-04-29 09:44:37,549 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 6 hr time horizon... +2026-04-29 09:44:37,575 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:40,945 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 10 hr time horizon... +2026-04-29 09:44:40,969 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:41,534 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 12 hr time horizon... +2026-04-29 09:44:41,552 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:41,820 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:41,842 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:43,744 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 5 hr time horizon... +2026-04-29 09:44:43,769 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:44,299 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:44,327 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 9 hr time horizon... +2026-04-29 09:44:44,345 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 6 hr time horizon... +2026-04-29 09:44:44,365 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:44,854 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 15 hr time horizon... +2026-04-29 09:44:44,878 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:45,733 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:45,765 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:47,302 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 9 hr time horizon... +2026-04-29 09:44:47,324 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:47,375 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 17 hr time horizon... +2026-04-29 09:44:47,397 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:47,998 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 11 hr time horizon... +2026-04-29 09:44:48,027 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:48,085 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:48,108 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:48,740 - __main__ - INFO - Finished processing 2018-01-04 22:00:00 4 hr time horizon... +2026-04-29 09:44:48,760 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:48,918 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 15 hr time horizon... +2026-04-29 09:44:48,945 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:49,466 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 13 hr time horizon... +2026-04-29 09:44:49,491 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:50,376 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 13 hr time horizon... +2026-04-29 09:44:50,398 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:50,987 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:51,016 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:52,401 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 13 hr time horizon... +2026-04-29 09:44:52,420 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 11 hr time horizon... +2026-04-29 09:44:52,933 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 3 hr time horizon... +2026-04-29 09:44:52,956 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:56,937 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 9 hr time horizon... +2026-04-29 09:44:56,959 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:57,042 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 3 hr time horizon... +2026-04-29 09:44:57,067 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:57,622 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 4 hr time horizon... +2026-04-29 09:44:57,648 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:59,226 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 5 hr time horizon... +2026-04-29 09:44:59,246 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:44:59,750 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 3 hr time horizon... +2026-04-29 09:44:59,770 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:00,268 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 9 hr time horizon... +2026-04-29 09:45:00,293 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:00,674 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:00,695 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:00,880 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 14 hr time horizon... +2026-04-29 09:45:00,903 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:01,823 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 4 hr time horizon... +2026-04-29 09:45:01,844 - __main__ - INFO - Processing values: 2018-01-18 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:02,322 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 1 hr time horizon... +2026-04-29 09:45:02,341 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:02,973 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 13 hr time horizon... +2026-04-29 09:45:02,995 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:03,232 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 18 hr time horizon... +2026-04-29 09:45:03,259 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:03,700 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:03,726 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:05,106 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 5 hr time horizon... +2026-04-29 09:45:05,129 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:05,194 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:05,217 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:06,738 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 11 hr time horizon... +2026-04-29 09:45:06,760 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:06,903 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 8 hr time horizon... +2026-04-29 09:45:06,922 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 17 hr time horizon... +2026-04-29 09:45:07,375 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 5 hr time horizon... +2026-04-29 09:45:07,394 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:10,592 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 13 hr time horizon... +2026-04-29 09:45:10,614 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:10,905 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 17 hr time horizon... +2026-04-29 09:45:10,930 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:12,873 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 14 hr time horizon... +2026-04-29 09:45:12,899 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:13,474 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 18 hr time horizon... +2026-04-29 09:45:13,495 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:14,173 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:14,195 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:15,237 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 16 hr time horizon... +2026-04-29 09:45:15,261 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:15,878 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:15,902 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:16,530 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 15 hr time horizon... +2026-04-29 09:45:16,552 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:16,655 - __main__ - INFO - Finished processing 2018-01-18 03:00:00 6 hr time horizon... +2026-04-29 09:45:16,678 - __main__ - INFO - Processing values: 2018-01-15 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:18,201 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 7 hr time horizon... +2026-04-29 09:45:18,224 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:18,369 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 12 hr time horizon... +2026-04-29 09:45:18,391 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:18,868 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 14 hr time horizon... +2026-04-29 09:45:18,885 - __main__ - INFO - Processing values: 2018-01-29 15:00:00 17 hr time horizon... +2026-04-29 09:45:19,052 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 7 hr time horizon... +2026-04-29 09:45:19,086 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:20,141 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 5 hr time horizon... +2026-04-29 09:45:20,161 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:20,287 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 18 hr time horizon... +2026-04-29 09:45:20,316 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:21,929 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 6 hr time horizon... +2026-04-29 09:45:21,953 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 8 hr time horizon... +2026-04-29 09:45:22,174 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 18 hr time horizon... +2026-04-29 09:45:22,195 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:22,453 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 17 hr time horizon... +2026-04-29 09:45:22,474 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:23,877 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 13 hr time horizon... +2026-04-29 09:45:23,905 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:26,808 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 3 hr time horizon... +2026-04-29 09:45:26,826 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 2 hr time horizon... +2026-04-29 09:45:26,874 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 5 hr time horizon... +2026-04-29 09:45:26,895 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:28,865 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 12 hr time horizon... +2026-04-29 09:45:28,890 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:29,490 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 14 hr time horizon... +2026-04-29 09:45:29,517 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:30,781 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 3 hr time horizon... +2026-04-29 09:45:30,798 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 13 hr time horizon... +2026-04-29 09:45:30,806 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 1 hr time horizon... +2026-04-29 09:45:30,822 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:30,997 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 15 hr time horizon... +2026-04-29 09:45:31,028 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:31,705 - __main__ - INFO - Finished processing 2018-01-15 23:00:00 3 hr time horizon... +2026-04-29 09:45:31,724 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:33,060 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 15 hr time horizon... +2026-04-29 09:45:33,088 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:34,498 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 9 hr time horizon... +2026-04-29 09:45:34,526 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:34,750 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:34,773 - __main__ - INFO - Processing values: 2018-01-03 09:00:00 16 hr time horizon... +2026-04-29 09:45:34,791 - __main__ - INFO - Finished processing 2018-01-29 15:00:00 17 hr time horizon... +2026-04-29 09:45:34,815 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:35,280 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 17 hr time horizon... +2026-04-29 09:45:35,305 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:36,174 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:36,204 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 7 hr time horizon... +2026-04-29 09:45:36,258 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 17 hr time horizon... +2026-04-29 09:45:36,281 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:38,264 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 8 hr time horizon... +2026-04-29 09:45:38,296 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 17 hr time horizon... +2026-04-29 09:45:38,351 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 3 hr time horizon... +2026-04-29 09:45:38,377 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:38,815 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 10 hr time horizon... +2026-04-29 09:45:38,836 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:39,585 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 13 hr time horizon... +2026-04-29 09:45:39,609 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:41,387 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 1 hr time horizon... +2026-04-29 09:45:41,408 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:42,513 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:42,540 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:43,401 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 2 hr time horizon... +2026-04-29 09:45:43,419 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:43,899 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 13 hr time horizon... +2026-04-29 09:45:43,920 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:45,501 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 1 hr time horizon... +2026-04-29 09:45:45,520 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:46,558 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 15 hr time horizon... +2026-04-29 09:45:46,582 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:46,812 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 9 hr time horizon... +2026-04-29 09:45:46,831 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 18 hr time horizon... +2026-04-29 09:45:46,877 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 11 hr time horizon... +2026-04-29 09:45:46,902 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:48,827 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 11 hr time horizon... +2026-04-29 09:45:48,852 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:49,842 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 6 hr time horizon... +2026-04-29 09:45:49,871 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:50,550 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 8 hr time horizon... +2026-04-29 09:45:50,573 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:50,748 - __main__ - INFO - Finished processing 2018-01-03 09:00:00 16 hr time horizon... +2026-04-29 09:45:50,776 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:51,404 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 6 hr time horizon... +2026-04-29 09:45:51,427 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 2 hr time horizon... +2026-04-29 09:45:51,461 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 16 hr time horizon... +2026-04-29 09:45:51,482 - __main__ - INFO - Processing values: 2018-01-24 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:51,667 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 7 hr time horizon... +2026-04-29 09:45:51,687 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:54,078 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:54,105 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:54,234 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 12 hr time horizon... +2026-04-29 09:45:54,263 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:55,197 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:55,222 - __main__ - INFO - Processing values: 2018-01-24 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:55,290 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 5 hr time horizon... +2026-04-29 09:45:55,311 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:56,281 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 15 hr time horizon... +2026-04-29 09:45:56,303 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:58,251 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 16 hr time horizon... +2026-04-29 09:45:58,275 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:58,617 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 11 hr time horizon... +2026-04-29 09:45:58,637 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:45:59,106 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 17 hr time horizon... +2026-04-29 09:45:59,130 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:00,999 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 12 hr time horizon... +2026-04-29 09:46:01,020 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:02,266 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 18 hr time horizon... +2026-04-29 09:46:02,289 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 18 hr time horizon... +2026-04-29 09:46:02,366 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 2 hr time horizon... +2026-04-29 09:46:02,385 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:02,603 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 12 hr time horizon... +2026-04-29 09:46:02,625 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:04,802 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 4 hr time horizon... +2026-04-29 09:46:04,823 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:05,891 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 1 hr time horizon... +2026-04-29 09:46:05,914 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:06,084 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 10 hr time horizon... +2026-04-29 09:46:06,111 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:06,456 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 9 hr time horizon... +2026-04-29 09:46:06,485 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:06,617 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 1 hr time horizon... +2026-04-29 09:46:06,636 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:07,077 - __main__ - INFO - Finished processing 2018-01-24 17:00:00 15 hr time horizon... +2026-04-29 09:46:07,105 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:08,025 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 2 hr time horizon... +2026-04-29 09:46:08,053 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:09,549 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 16 hr time horizon... +2026-04-29 09:46:09,573 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:09,748 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 8 hr time horizon... +2026-04-29 09:46:09,770 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:10,467 - __main__ - INFO - Finished processing 2018-01-24 12:00:00 15 hr time horizon... +2026-04-29 09:46:10,495 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:11,016 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:11,037 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:12,463 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 4 hr time horizon... +2026-04-29 09:46:12,497 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:13,524 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 5 hr time horizon... +2026-04-29 09:46:13,529 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 9 hr time horizon... +2026-04-29 09:46:13,547 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 7 hr time horizon... +2026-04-29 09:46:13,553 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:14,419 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 14 hr time horizon... +2026-04-29 09:46:14,452 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:16,938 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 16 hr time horizon... +2026-04-29 09:46:16,960 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:17,466 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 1 hr time horizon... +2026-04-29 09:46:17,484 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:17,626 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 18 hr time horizon... +2026-04-29 09:46:17,648 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:18,326 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 16 hr time horizon... +2026-04-29 09:46:18,350 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:20,049 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 5 hr time horizon... +2026-04-29 09:46:20,071 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:20,718 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:20,739 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:21,027 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 16 hr time horizon... +2026-04-29 09:46:21,048 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:21,441 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 15 hr time horizon... +2026-04-29 09:46:21,464 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:22,221 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 8 hr time horizon... +2026-04-29 09:46:22,242 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 18 hr time horizon... +2026-04-29 09:46:22,362 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 13 hr time horizon... +2026-04-29 09:46:22,383 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:23,490 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 14 hr time horizon... +2026-04-29 09:46:23,511 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:25,778 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 16 hr time horizon... +2026-04-29 09:46:25,799 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:26,055 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 5 hr time horizon... +2026-04-29 09:46:26,080 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:26,483 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 7 hr time horizon... +2026-04-29 09:46:26,504 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:27,405 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 2 hr time horizon... +2026-04-29 09:46:27,427 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:27,740 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 1 hr time horizon... +2026-04-29 09:46:27,760 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:29,070 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 12 hr time horizon... +2026-04-29 09:46:29,101 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:30,393 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 7 hr time horizon... +2026-04-29 09:46:30,424 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:31,287 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 16 hr time horizon... +2026-04-29 09:46:31,307 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:33,169 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 12 hr time horizon... +2026-04-29 09:46:33,209 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:33,428 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 5 hr time horizon... +2026-04-29 09:46:33,453 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:33,610 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 4 hr time horizon... +2026-04-29 09:46:33,634 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:34,834 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 8 hr time horizon... +2026-04-29 09:46:34,858 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:35,105 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 13 hr time horizon... +2026-04-29 09:46:35,132 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:35,998 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 1 hr time horizon... +2026-04-29 09:46:36,022 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:36,162 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 2 hr time horizon... +2026-04-29 09:46:36,184 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:36,886 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:36,911 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:37,001 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 18 hr time horizon... +2026-04-29 09:46:37,023 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:37,576 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 3 hr time horizon... +2026-04-29 09:46:37,599 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:39,012 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 10 hr time horizon... +2026-04-29 09:46:39,036 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:41,217 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 5 hr time horizon... +2026-04-29 09:46:41,219 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 18 hr time horizon... +2026-04-29 09:46:41,242 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:41,249 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:41,772 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 11 hr time horizon... +2026-04-29 09:46:41,796 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:43,053 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 3 hr time horizon... +2026-04-29 09:46:43,075 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 15 hr time horizon... +2026-04-29 09:46:43,080 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 9 hr time horizon... +2026-04-29 09:46:43,100 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:45,019 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 8 hr time horizon... +2026-04-29 09:46:45,041 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:47,137 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 13 hr time horizon... +2026-04-29 09:46:47,157 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 12 hr time horizon... +2026-04-29 09:46:47,240 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 7 hr time horizon... +2026-04-29 09:46:47,267 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:48,553 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:48,573 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:48,692 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 17 hr time horizon... +2026-04-29 09:46:48,714 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:50,460 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 18 hr time horizon... +2026-04-29 09:46:50,486 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:50,495 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 6 hr time horizon... +2026-04-29 09:46:50,522 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:51,111 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 1 hr time horizon... +2026-04-29 09:46:51,135 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:51,917 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 7 hr time horizon... +2026-04-29 09:46:51,963 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:52,083 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 9 hr time horizon... +2026-04-29 09:46:52,107 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:52,864 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 11 hr time horizon... +2026-04-29 09:46:52,889 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:53,009 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 16 hr time horizon... +2026-04-29 09:46:53,033 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:53,574 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 15 hr time horizon... +2026-04-29 09:46:53,603 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:54,650 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 1 hr time horizon... +2026-04-29 09:46:54,672 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:57,824 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:57,848 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:58,129 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 16 hr time horizon... +2026-04-29 09:46:58,158 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:58,448 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 15 hr time horizon... +2026-04-29 09:46:58,476 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:59,231 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 15 hr time horizon... +2026-04-29 09:46:59,253 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:59,729 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:46:59,756 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:00,779 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 10 hr time horizon... +2026-04-29 09:47:00,804 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:02,724 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 6 hr time horizon... +2026-04-29 09:47:02,746 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:02,920 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 12 hr time horizon... +2026-04-29 09:47:02,941 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:03,675 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 16 hr time horizon... +2026-04-29 09:47:03,695 - __main__ - INFO - Processing values: 2018-01-19 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:04,202 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 16 hr time horizon... +2026-04-29 09:47:04,223 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:05,181 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:05,203 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:06,141 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 5 hr time horizon... +2026-04-29 09:47:06,166 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:06,658 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 14 hr time horizon... +2026-04-29 09:47:06,686 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:07,876 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 13 hr time horizon... +2026-04-29 09:47:07,898 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:08,112 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 18 hr time horizon... +2026-04-29 09:47:08,136 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:08,737 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 1 hr time horizon... +2026-04-29 09:47:08,759 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 12 hr time horizon... +2026-04-29 09:47:08,824 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 8 hr time horizon... +2026-04-29 09:47:08,861 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:09,311 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 10 hr time horizon... +2026-04-29 09:47:09,338 - __main__ - INFO - Processing values: 2018-01-21 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:11,736 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 9 hr time horizon... +2026-04-29 09:47:11,763 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:12,666 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 2 hr time horizon... +2026-04-29 09:47:12,686 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:13,205 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 4 hr time horizon... +2026-04-29 09:47:13,228 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:13,403 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 8 hr time horizon... +2026-04-29 09:47:13,426 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:14,449 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:14,471 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:15,069 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 15 hr time horizon... +2026-04-29 09:47:15,093 - __main__ - INFO - Processing values: 2018-01-21 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:15,772 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 13 hr time horizon... +2026-04-29 09:47:15,793 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:18,479 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 6 hr time horizon... +2026-04-29 09:47:18,512 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:18,684 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 5 hr time horizon... +2026-04-29 09:47:18,710 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:19,415 - __main__ - INFO - Finished processing 2018-01-19 15:00:00 7 hr time horizon... +2026-04-29 09:47:19,438 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 16 hr time horizon... +2026-04-29 09:47:19,625 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 12 hr time horizon... +2026-04-29 09:47:19,654 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:20,837 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:20,860 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:21,971 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:21,995 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:22,479 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 6 hr time horizon... +2026-04-29 09:47:22,504 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:23,771 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 3 hr time horizon... +2026-04-29 09:47:23,792 - __main__ - INFO - Processing values: 2018-01-22 12:00:00 13 hr time horizon... +2026-04-29 09:47:23,893 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 1 hr time horizon... +2026-04-29 09:47:23,918 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:24,403 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 12 hr time horizon... +2026-04-29 09:47:24,435 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:24,576 - __main__ - INFO - Finished processing 2018-01-21 10:00:00 4 hr time horizon... +2026-04-29 09:47:24,599 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:25,072 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 6 hr time horizon... +2026-04-29 09:47:25,097 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:27,283 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 11 hr time horizon... +2026-04-29 09:47:27,304 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:28,324 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 2 hr time horizon... +2026-04-29 09:47:28,343 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:28,462 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 15 hr time horizon... +2026-04-29 09:47:28,491 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:29,545 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 9 hr time horizon... +2026-04-29 09:47:29,570 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:29,817 - __main__ - INFO - Finished processing 2018-01-21 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:29,849 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:31,223 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 14 hr time horizon... +2026-04-29 09:47:31,244 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:31,402 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 13 hr time horizon... +2026-04-29 09:47:31,428 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:34,345 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 9 hr time horizon... +2026-04-29 09:47:34,369 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:34,592 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 12 hr time horizon... +2026-04-29 09:47:34,614 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 2 hr time horizon... +2026-04-29 09:47:34,662 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 16 hr time horizon... +2026-04-29 09:47:34,681 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 18 hr time horizon... +2026-04-29 09:47:34,758 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:34,792 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:37,383 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:37,408 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:37,974 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:38,002 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 8 hr time horizon... +2026-04-29 09:47:38,052 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 17 hr time horizon... +2026-04-29 09:47:38,077 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,035 - __main__ - INFO - Finished processing 2018-01-22 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,059 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,252 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 3 hr time horizon... +2026-04-29 09:47:39,271 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,492 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 6 hr time horizon... +2026-04-29 09:47:39,511 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,667 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 11 hr time horizon... +2026-04-29 09:47:39,694 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:39,716 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 10 hr time horizon... +2026-04-29 09:47:39,735 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:42,257 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 7 hr time horizon... +2026-04-29 09:47:42,280 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:42,760 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:42,780 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:43,069 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 1 hr time horizon... +2026-04-29 09:47:43,089 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:44,367 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 10 hr time horizon... +2026-04-29 09:47:44,388 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:44,668 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 16 hr time horizon... +2026-04-29 09:47:44,689 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:45,318 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 13 hr time horizon... +2026-04-29 09:47:45,338 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:48,039 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 2 hr time horizon... +2026-04-29 09:47:48,057 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:48,585 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 1 hr time horizon... +2026-04-29 09:47:48,604 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:50,118 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 15 hr time horizon... +2026-04-29 09:47:50,147 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:50,237 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 10 hr time horizon... +2026-04-29 09:47:50,262 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:50,364 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 18 hr time horizon... +2026-04-29 09:47:50,383 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:51,872 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 10 hr time horizon... +2026-04-29 09:47:51,896 - __main__ - INFO - Processing values: 2018-01-06 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:52,127 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 8 hr time horizon... +2026-04-29 09:47:52,161 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:52,762 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 5 hr time horizon... +2026-04-29 09:47:52,783 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:53,749 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 12 hr time horizon... +2026-04-29 09:47:53,771 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:53,796 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 4 hr time horizon... +2026-04-29 09:47:53,816 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:55,091 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 14 hr time horizon... +2026-04-29 09:47:55,113 - __main__ - INFO - Processing values: 2018-01-11 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:55,977 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 2 hr time horizon... +2026-04-29 09:47:56,002 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:56,540 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:56,565 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:57,551 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 1 hr time horizon... +2026-04-29 09:47:57,573 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:57,664 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 11 hr time horizon... +2026-04-29 09:47:57,686 - __main__ - INFO - Processing values: 2018-01-10 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:59,423 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 9 hr time horizon... +2026-04-29 09:47:59,447 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:47:59,891 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 12 hr time horizon... +2026-04-29 09:47:59,913 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:00,697 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 15 hr time horizon... +2026-04-29 09:48:00,720 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:03,513 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:03,539 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:03,770 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:03,794 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:05,142 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 3 hr time horizon... +2026-04-29 09:48:05,177 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:05,347 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:05,369 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:06,477 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 9 hr time horizon... +2026-04-29 09:48:06,502 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:07,014 - __main__ - INFO - Finished processing 2018-01-06 18:00:00 2 hr time horizon... +2026-04-29 09:48:07,033 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:07,632 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 6 hr time horizon... +2026-04-29 09:48:07,653 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:07,954 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 16 hr time horizon... +2026-04-29 09:48:07,979 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:08,145 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 8 hr time horizon... +2026-04-29 09:48:08,165 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:08,667 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 15 hr time horizon... +2026-04-29 09:48:08,688 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:09,234 - __main__ - INFO - Finished processing 2018-01-11 12:00:00 14 hr time horizon... +2026-04-29 09:48:09,259 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:10,608 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:10,629 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:12,062 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 8 hr time horizon... +2026-04-29 09:48:12,086 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:12,200 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 7 hr time horizon... +2026-04-29 09:48:12,223 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:12,406 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 7 hr time horizon... +2026-04-29 09:48:12,427 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:13,158 - __main__ - INFO - Finished processing 2018-01-10 23:00:00 5 hr time horizon... +2026-04-29 09:48:13,179 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:13,762 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 2 hr time horizon... +2026-04-29 09:48:13,780 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:14,443 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 9 hr time horizon... +2026-04-29 09:48:14,467 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:16,297 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 14 hr time horizon... +2026-04-29 09:48:16,324 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:17,348 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:17,366 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:17,974 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 10 hr time horizon... +2026-04-29 09:48:17,998 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:18,844 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 7 hr time horizon... +2026-04-29 09:48:18,865 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:19,365 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 8 hr time horizon... +2026-04-29 09:48:19,390 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:20,985 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 15 hr time horizon... +2026-04-29 09:48:21,009 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:21,557 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:21,593 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:21,805 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 4 hr time horizon... +2026-04-29 09:48:21,830 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:22,000 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 4 hr time horizon... +2026-04-29 09:48:22,024 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:22,576 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 6 hr time horizon... +2026-04-29 09:48:22,595 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:23,628 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 12 hr time horizon... +2026-04-29 09:48:23,649 - __main__ - INFO - Processing values: 2018-01-24 16:00:00 13 hr time horizon... +2026-04-29 09:48:23,768 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:23,786 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:24,620 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 2 hr time horizon... +2026-04-29 09:48:24,640 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:25,899 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 2 hr time horizon... +2026-04-29 09:48:25,917 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:26,003 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 18 hr time horizon... +2026-04-29 09:48:26,022 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:27,066 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:27,086 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:28,298 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 12 hr time horizon... +2026-04-29 09:48:28,318 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:28,482 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 1 hr time horizon... +2026-04-29 09:48:28,504 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 10 hr time horizon... +2026-04-29 09:48:28,615 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 7 hr time horizon... +2026-04-29 09:48:28,635 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:31,105 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 7 hr time horizon... +2026-04-29 09:48:31,126 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:31,624 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 14 hr time horizon... +2026-04-29 09:48:31,646 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:32,958 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 14 hr time horizon... +2026-04-29 09:48:32,979 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 14 hr time horizon... +2026-04-29 09:48:33,048 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:33,075 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:33,376 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 11 hr time horizon... +2026-04-29 09:48:33,402 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:34,293 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:34,313 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:35,741 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 18 hr time horizon... +2026-04-29 09:48:35,767 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 15 hr time horizon... +2026-04-29 09:48:35,847 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:35,870 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:36,463 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 12 hr time horizon... +2026-04-29 09:48:36,498 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:38,252 - __main__ - INFO - Finished processing 2018-01-24 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:38,274 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:38,981 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 9 hr time horizon... +2026-04-29 09:48:39,004 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:39,257 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 4 hr time horizon... +2026-04-29 09:48:39,289 - __main__ - INFO - Processing values: 2018-01-23 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:40,051 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 2 hr time horizon... +2026-04-29 09:48:40,069 - __main__ - INFO - Processing values: 2018-01-03 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:40,565 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 14 hr time horizon... +2026-04-29 09:48:40,588 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:41,875 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:41,897 - __main__ - INFO - Processing values: 2018-01-24 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:42,894 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 13 hr time horizon... +2026-04-29 09:48:42,925 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:43,582 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 10 hr time horizon... +2026-04-29 09:48:43,602 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:44,190 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 12 hr time horizon... +2026-04-29 09:48:44,210 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 13 hr time horizon... +2026-04-29 09:48:44,343 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 7 hr time horizon... +2026-04-29 09:48:44,366 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:47,077 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 15 hr time horizon... +2026-04-29 09:48:47,099 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:47,281 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 14 hr time horizon... +2026-04-29 09:48:47,316 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:47,921 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 2 hr time horizon... +2026-04-29 09:48:47,942 - __main__ - INFO - Processing values: 2018-01-11 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:48,887 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 14 hr time horizon... +2026-04-29 09:48:48,911 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:49,143 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 11 hr time horizon... +2026-04-29 09:48:49,169 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:49,234 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 14 hr time horizon... +2026-04-29 09:48:49,255 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:51,046 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 15 hr time horizon... +2026-04-29 09:48:51,068 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:52,068 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 5 hr time horizon... +2026-04-29 09:48:52,095 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:52,236 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 7 hr time horizon... +2026-04-29 09:48:52,265 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:53,387 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 7 hr time horizon... +2026-04-29 09:48:53,410 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:54,684 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 1 hr time horizon... +2026-04-29 09:48:54,709 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 14 hr time horizon... +2026-04-29 09:48:54,724 - __main__ - INFO - Finished processing 2018-01-23 18:00:00 2 hr time horizon... +2026-04-29 09:48:54,744 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:55,308 - __main__ - INFO - Finished processing 2018-01-03 10:00:00 9 hr time horizon... +2026-04-29 09:48:55,329 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:57,188 - __main__ - INFO - Finished processing 2018-01-24 17:00:00 18 hr time horizon... +2026-04-29 09:48:57,212 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:58,172 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 2 hr time horizon... +2026-04-29 09:48:58,195 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:58,365 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 13 hr time horizon... +2026-04-29 09:48:58,387 - __main__ - INFO - Processing values: 2018-01-17 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:59,269 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 3 hr time horizon... +2026-04-29 09:48:59,301 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:48:59,842 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 6 hr time horizon... +2026-04-29 09:48:59,862 - __main__ - INFO - Processing values: 2018-01-24 17:00:00 4 hr time horizon... +2026-04-29 09:49:00,108 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 13 hr time horizon... +2026-04-29 09:49:00,131 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:02,492 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 1 hr time horizon... +2026-04-29 09:49:02,520 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:03,327 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 15 hr time horizon... +2026-04-29 09:49:03,351 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:03,537 - __main__ - INFO - Finished processing 2018-01-11 22:00:00 12 hr time horizon... +2026-04-29 09:49:03,570 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:04,314 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 6 hr time horizon... +2026-04-29 09:49:04,338 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:04,632 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 8 hr time horizon... +2026-04-29 09:49:04,657 - __main__ - INFO - Processing values: 2018-01-27 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:04,911 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 14 hr time horizon... +2026-04-29 09:49:04,936 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:06,660 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 13 hr time horizon... +2026-04-29 09:49:06,684 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:07,358 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 2 hr time horizon... +2026-04-29 09:49:07,377 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:08,772 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 2 hr time horizon... +2026-04-29 09:49:08,793 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:09,070 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:09,093 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:09,703 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 3 hr time horizon... +2026-04-29 09:49:09,725 - __main__ - INFO - Processing values: 2018-01-25 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:10,757 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:10,781 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:10,971 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 2 hr time horizon... +2026-04-29 09:49:10,993 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:12,785 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 4 hr time horizon... +2026-04-29 09:49:12,808 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:13,405 - __main__ - INFO - Finished processing 2018-01-17 09:00:00 8 hr time horizon... +2026-04-29 09:49:13,430 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:13,480 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 18 hr time horizon... +2026-04-29 09:49:13,500 - __main__ - INFO - Processing values: 2018-01-26 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:13,905 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 13 hr time horizon... +2026-04-29 09:49:13,933 - __main__ - INFO - Processing values: 2018-01-29 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:14,850 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 4 hr time horizon... +2026-04-29 09:49:14,871 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:17,023 - __main__ - INFO - Finished processing 2018-01-24 17:00:00 4 hr time horizon... +2026-04-29 09:49:17,052 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:17,207 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 9 hr time horizon... +2026-04-29 09:49:17,235 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:49:18,525 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:18,552 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:19,084 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 4 hr time horizon... +2026-04-29 09:49:19,107 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:19,257 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 8 hr time horizon... +2026-04-29 09:49:19,283 - __main__ - INFO - Processing values: 2018-01-21 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:19,808 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 6 hr time horizon... +2026-04-29 09:49:19,830 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:20,346 - __main__ - INFO - Finished processing 2018-01-27 01:00:00 17 hr time horizon... +2026-04-29 09:49:20,373 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:21,795 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 5 hr time horizon... +2026-04-29 09:49:21,815 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:22,765 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:22,801 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:24,279 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:24,302 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:25,131 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 3 hr time horizon... +2026-04-29 09:49:25,158 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:25,302 - __main__ - INFO - Finished processing 2018-01-25 22:00:00 2 hr time horizon... +2026-04-29 09:49:25,323 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:25,602 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 6 hr time horizon... +2026-04-29 09:49:25,628 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:26,055 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 1 hr time horizon... +2026-04-29 09:49:26,070 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:26,872 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:49:26,895 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:29,517 - __main__ - INFO - Finished processing 2018-01-26 21:00:00 15 hr time horizon... +2026-04-29 09:49:29,541 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:30,003 - __main__ - INFO - Finished processing 2018-01-29 15:00:00 13 hr time horizon... +2026-04-29 09:49:30,024 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 17 hr time horizon... +2026-04-29 09:49:30,035 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 1 hr time horizon... +2026-04-29 09:49:30,053 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 3 hr time horizon... +2026-04-29 09:49:30,185 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 6 hr time horizon... +2026-04-29 09:49:30,206 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:32,790 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 14 hr time horizon... +2026-04-29 09:49:32,816 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:33,549 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 12 hr time horizon... +2026-04-29 09:49:33,581 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:33,874 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 3 hr time horizon... +2026-04-29 09:49:33,896 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:35,060 - __main__ - INFO - Finished processing 2018-01-21 11:00:00 12 hr time horizon... +2026-04-29 09:49:35,083 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:35,255 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 15 hr time horizon... +2026-04-29 09:49:35,276 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:35,646 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 18 hr time horizon... +2026-04-29 09:49:35,669 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:36,655 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 16 hr time horizon... +2026-04-29 09:49:36,676 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:37,712 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 12 hr time horizon... +2026-04-29 09:49:37,736 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:38,309 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 16 hr time horizon... +2026-04-29 09:49:38,335 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:38,582 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 9 hr time horizon... +2026-04-29 09:49:38,606 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:41,316 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 3 hr time horizon... +2026-04-29 09:49:41,338 - __main__ - INFO - Processing values: 2018-01-10 11:00:00 1 hr time horizon... +2026-04-29 09:49:41,414 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 1 hr time horizon... +2026-04-29 09:49:41,434 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:41,608 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 11 hr time horizon... +2026-04-29 09:49:41,635 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:44,015 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 11 hr time horizon... +2026-04-29 09:49:44,045 - __main__ - INFO - Processing values: 2018-01-19 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:44,695 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:44,716 - __main__ - INFO - Processing values: 2018-01-25 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:45,156 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 17 hr time horizon... +2026-04-29 09:49:45,182 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 4 hr time horizon... +2026-04-29 09:49:45,236 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 3 hr time horizon... +2026-04-29 09:49:45,256 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 6 hr time horizon... +2026-04-29 09:49:45,289 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 14 hr time horizon... +2026-04-29 09:49:45,310 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 14 hr time horizon... +2026-04-29 09:49:45,735 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 17 hr time horizon... +2026-04-29 09:49:45,756 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:48,924 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 3 hr time horizon... +2026-04-29 09:49:48,946 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:49,054 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:49,082 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:49,704 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 13 hr time horizon... +2026-04-29 09:49:49,730 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:50,207 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 6 hr time horizon... +2026-04-29 09:49:50,224 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:51,275 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 5 hr time horizon... +2026-04-29 09:49:51,302 - __main__ - INFO - Processing values: 2018-01-13 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:51,498 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:51,522 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:52,507 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 9 hr time horizon... +2026-04-29 09:49:52,529 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:53,231 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 16 hr time horizon... +2026-04-29 09:49:53,250 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:53,827 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 15 hr time horizon... +2026-04-29 09:49:53,851 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:53,963 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 15 hr time horizon... +2026-04-29 09:49:53,988 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:56,130 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:56,156 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:56,398 - __main__ - INFO - Finished processing 2018-01-10 11:00:00 1 hr time horizon... +2026-04-29 09:49:56,422 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:56,886 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 4 hr time horizon... +2026-04-29 09:49:56,911 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:58,238 - __main__ - INFO - Finished processing 2018-01-25 06:00:00 4 hr time horizon... +2026-04-29 09:49:58,256 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:59,579 - __main__ - INFO - Finished processing 2018-01-19 19:00:00 5 hr time horizon... +2026-04-29 09:49:59,602 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:49:59,958 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 6 hr time horizon... +2026-04-29 09:49:59,979 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:01,039 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 16 hr time horizon... +2026-04-29 09:50:01,068 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:01,914 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 14 hr time horizon... +2026-04-29 09:50:01,937 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:02,553 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 4 hr time horizon... +2026-04-29 09:50:02,574 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:03,588 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 12 hr time horizon... +2026-04-29 09:50:03,616 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 15 hr time horizon... +2026-04-29 09:50:03,694 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 3 hr time horizon... +2026-04-29 09:50:03,730 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:04,242 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 7 hr time horizon... +2026-04-29 09:50:04,269 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:05,187 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 10 hr time horizon... +2026-04-29 09:50:05,212 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:06,633 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 17 hr time horizon... +2026-04-29 09:50:06,667 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:06,750 - __main__ - INFO - Finished processing 2018-01-13 06:00:00 11 hr time horizon... +2026-04-29 09:50:06,775 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:07,139 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 6 hr time horizon... +2026-04-29 09:50:07,163 - __main__ - INFO - Processing values: 2018-01-02 09:00:00 3 hr time horizon... +2026-04-29 09:50:07,428 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 10 hr time horizon... +2026-04-29 09:50:07,450 - __main__ - INFO - Processing values: 2018-01-26 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:08,870 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 5 hr time horizon... +2026-04-29 09:50:08,893 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:09,701 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:09,723 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:11,661 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 8 hr time horizon... +2026-04-29 09:50:11,688 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:12,468 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 16 hr time horizon... +2026-04-29 09:50:12,492 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:12,680 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 15 hr time horizon... +2026-04-29 09:50:12,706 - __main__ - INFO - Processing values: 2018-01-05 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:50:13,749 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:13,777 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:15,106 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 10 hr time horizon... +2026-04-29 09:50:15,132 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:15,287 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:15,313 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:16,349 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:16,372 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:18,215 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 4 hr time horizon... +2026-04-29 09:50:18,233 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:18,355 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 5 hr time horizon... +2026-04-29 09:50:18,381 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 14 hr time horizon... +2026-04-29 09:50:18,408 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 15 hr time horizon... +2026-04-29 09:50:18,436 - __main__ - INFO - Processing values: 2018-01-02 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:19,259 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 18 hr time horizon... +2026-04-29 09:50:19,289 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:19,504 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 15 hr time horizon... +2026-04-29 09:50:19,526 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:50:19,814 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:19,840 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:21,719 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 6 hr time horizon... +2026-04-29 09:50:21,741 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:21,945 - __main__ - INFO - Finished processing 2018-01-02 09:00:00 3 hr time horizon... +2026-04-29 09:50:21,966 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:22,441 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:22,465 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:23,443 - __main__ - INFO - Finished processing 2018-01-26 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:23,469 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:24,895 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 2 hr time horizon... +2026-04-29 09:50:24,918 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:25,107 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 16 hr time horizon... +2026-04-29 09:50:25,132 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:27,158 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 12 hr time horizon... +2026-04-29 09:50:27,183 - __main__ - INFO - Processing values: 2018-01-10 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:27,937 - __main__ - INFO - Finished processing 2018-01-05 12:00:00 7 hr time horizon... +2026-04-29 09:50:27,957 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:28,617 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 5 hr time horizon... +2026-04-29 09:50:28,641 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:29,217 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 18 hr time horizon... +2026-04-29 09:50:29,239 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:30,169 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:30,190 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:30,921 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 9 hr time horizon... +2026-04-29 09:50:30,942 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:32,775 - __main__ - INFO - Finished processing 2018-01-02 15:00:00 16 hr time horizon... +2026-04-29 09:50:32,796 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:33,233 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 11 hr time horizon... +2026-04-29 09:50:33,253 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:33,293 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 11 hr time horizon... +2026-04-29 09:50:33,315 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:34,228 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:34,254 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:34,748 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 8 hr time horizon... +2026-04-29 09:50:34,770 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:35,444 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 16 hr time horizon... +2026-04-29 09:50:35,466 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:35,731 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 18 hr time horizon... +2026-04-29 09:50:35,760 - __main__ - INFO - Processing values: 2018-01-26 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:37,149 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:37,172 - __main__ - INFO - Processing values: 2018-01-25 13:00:00 2 hr time horizon... +2026-04-29 09:50:37,180 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 9 hr time horizon... +2026-04-29 09:50:37,204 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:38,093 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 13 hr time horizon... +2026-04-29 09:50:38,115 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:39,238 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 11 hr time horizon... +2026-04-29 09:50:39,265 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:39,274 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 18 hr time horizon... +2026-04-29 09:50:39,293 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 8 hr time horizon... +2026-04-29 09:50:39,484 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 2 hr time horizon... +2026-04-29 09:50:39,503 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:41,741 - __main__ - INFO - Finished processing 2018-01-10 11:00:00 7 hr time horizon... +2026-04-29 09:50:41,767 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:42,805 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 1 hr time horizon... +2026-04-29 09:50:42,832 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:43,236 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 6 hr time horizon... +2026-04-29 09:50:43,262 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:45,157 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 10 hr time horizon... +2026-04-29 09:50:45,179 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:45,659 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 13 hr time horizon... +2026-04-29 09:50:45,685 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:45,910 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 5 hr time horizon... +2026-04-29 09:50:45,933 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 13 hr time horizon... +2026-04-29 09:50:46,032 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 6 hr time horizon... +2026-04-29 09:50:46,052 - __main__ - INFO - Processing values: 2018-01-06 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:47,073 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 14 hr time horizon... +2026-04-29 09:50:47,106 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:48,594 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 17 hr time horizon... +2026-04-29 09:50:48,621 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:48,795 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 14 hr time horizon... +2026-04-29 09:50:48,825 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:49,445 - __main__ - INFO - Finished processing 2018-01-26 10:00:00 1 hr time horizon... +2026-04-29 09:50:49,466 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:49,557 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 17 hr time horizon... +2026-04-29 09:50:49,579 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:49,840 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 5 hr time horizon... +2026-04-29 09:50:49,862 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:51,069 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 1 hr time horizon... +2026-04-29 09:50:51,087 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:51,684 - __main__ - INFO - Finished processing 2018-01-25 13:00:00 2 hr time horizon... +2026-04-29 09:50:51,706 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:52,610 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 1 hr time horizon... +2026-04-29 09:50:52,630 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:53,985 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 3 hr time horizon... +2026-04-29 09:50:54,016 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:54,742 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:54,772 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:55,032 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 8 hr time horizon... +2026-04-29 09:50:55,055 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:56,487 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 8 hr time horizon... +2026-04-29 09:50:56,511 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:57,107 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 2 hr time horizon... +2026-04-29 09:50:57,128 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:57,659 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 1 hr time horizon... +2026-04-29 09:50:57,679 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:50:59,439 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 17 hr time horizon... +2026-04-29 09:50:59,462 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:00,424 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 13 hr time horizon... +2026-04-29 09:51:00,448 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:00,552 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 15 hr time horizon... +2026-04-29 09:51:00,578 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:02,214 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 7 hr time horizon... +2026-04-29 09:51:02,236 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:02,330 - __main__ - INFO - Finished processing 2018-01-06 11:00:00 8 hr time horizon... +2026-04-29 09:51:02,354 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:02,712 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 7 hr time horizon... +2026-04-29 09:51:02,732 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:03,683 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 6 hr time horizon... +2026-04-29 09:51:03,706 - __main__ - INFO - Processing values: 2018-01-13 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:04,536 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 10 hr time horizon... +2026-04-29 09:51:04,555 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:04,770 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 12 hr time horizon... +2026-04-29 09:51:04,793 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:05,893 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 16 hr time horizon... +2026-04-29 09:51:05,918 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:06,172 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 13 hr time horizon... +2026-04-29 09:51:06,196 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:07,165 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 12 hr time horizon... +2026-04-29 09:51:07,187 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:08,035 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 3 hr time horizon... +2026-04-29 09:51:08,053 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:09,405 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 5 hr time horizon... +2026-04-29 09:51:09,425 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:10,060 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 8 hr time horizon... +2026-04-29 09:51:10,085 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:11,985 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 5 hr time horizon... +2026-04-29 09:51:12,013 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:12,654 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 10 hr time horizon... +2026-04-29 09:51:12,673 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:12,721 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 10 hr time horizon... +2026-04-29 09:51:12,743 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:13,696 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 1 hr time horizon... +2026-04-29 09:51:13,716 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:15,190 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 2 hr time horizon... +2026-04-29 09:51:15,222 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:15,959 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 8 hr time horizon... +2026-04-29 09:51:15,985 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:16,459 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 2 hr time horizon... +2026-04-29 09:51:16,478 - __main__ - INFO - Processing values: 2018-01-25 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:17,406 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:17,430 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:18,036 - __main__ - INFO - Finished processing 2018-01-13 13:00:00 13 hr time horizon... +2026-04-29 09:51:18,056 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:18,389 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 6 hr time horizon... +2026-04-29 09:51:18,413 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:19,901 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 1 hr time horizon... +2026-04-29 09:51:19,924 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:20,076 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 5 hr time horizon... +2026-04-29 09:51:20,098 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:20,534 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 3 hr time horizon... +2026-04-29 09:51:20,555 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:22,050 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:22,077 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 18 hr time horizon... +2026-04-29 09:51:22,229 - __main__ - INFO - Finished processing 2018-01-29 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:51:22,250 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:23,296 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 3 hr time horizon... +2026-04-29 09:51:23,317 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:24,149 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 16 hr time horizon... +2026-04-29 09:51:24,171 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:25,528 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:25,549 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:27,459 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 5 hr time horizon... +2026-04-29 09:51:27,481 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:27,759 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 1 hr time horizon... +2026-04-29 09:51:27,781 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:27,950 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 18 hr time horizon... +2026-04-29 09:51:27,974 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:28,856 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 14 hr time horizon... +2026-04-29 09:51:28,878 - __main__ - INFO - Processing values: 2018-01-24 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:30,218 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 12 hr time horizon... +2026-04-29 09:51:30,240 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:30,741 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 17 hr time horizon... +2026-04-29 09:51:30,765 - __main__ - INFO - Processing values: 2018-01-27 20:00:00 11 hr time horizon... +2026-04-29 09:51:30,796 - __main__ - INFO - Finished processing 2018-01-25 10:00:00 1 hr time horizon... +2026-04-29 09:51:30,814 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:31,074 - __main__ - INFO - Finished processing 2018-01-29 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:31,100 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:32,142 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 8 hr time horizon... +2026-04-29 09:51:32,164 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:33,676 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 8 hr time horizon... +2026-04-29 09:51:33,702 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:34,444 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:34,468 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:35,429 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:35,458 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 9 hr time horizon... +2026-04-29 09:51:35,536 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 8 hr time horizon... +2026-04-29 09:51:35,562 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:36,426 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 10 hr time horizon... +2026-04-29 09:51:36,448 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:37,442 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 7 hr time horizon... +2026-04-29 09:51:37,461 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:37,740 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 18 hr time horizon... +2026-04-29 09:51:37,762 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:38,357 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 18 hr time horizon... +2026-04-29 09:51:38,378 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:40,375 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 3 hr time horizon... +2026-04-29 09:51:40,396 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:40,688 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 7 hr time horizon... +2026-04-29 09:51:40,708 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:42,636 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:42,660 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:43,079 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 6 hr time horizon... +2026-04-29 09:51:43,098 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:43,342 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 3 hr time horizon... +2026-04-29 09:51:43,366 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:43,930 - __main__ - INFO - Finished processing 2018-01-24 15:00:00 16 hr time horizon... +2026-04-29 09:51:43,955 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:45,797 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 16 hr time horizon... +2026-04-29 09:51:45,821 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 6 hr time horizon... +2026-04-29 09:51:45,880 - __main__ - INFO - Finished processing 2018-01-27 20:00:00 11 hr time horizon... +2026-04-29 09:51:45,900 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:46,165 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:46,184 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:47,523 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 18 hr time horizon... +2026-04-29 09:51:47,555 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:49,091 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 13 hr time horizon... +2026-04-29 09:51:49,118 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:51:49,401 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:49,424 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:50,227 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 9 hr time horizon... +2026-04-29 09:51:50,246 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:50,725 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 10 hr time horizon... +2026-04-29 09:51:50,752 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:50,954 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:50,975 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:51,799 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 7 hr time horizon... +2026-04-29 09:51:51,818 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 15 hr time horizon... +2026-04-29 09:51:51,940 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 1 hr time horizon... +2026-04-29 09:51:51,958 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:52,123 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 5 hr time horizon... +2026-04-29 09:51:52,145 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 2 hr time horizon... +2026-04-29 09:51:52,364 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:52,386 - __main__ - INFO - Processing values: 2018-01-29 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:54,152 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 9 hr time horizon... +2026-04-29 09:51:54,183 - __main__ - INFO - Processing values: 2018-01-09 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:55,624 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 10 hr time horizon... +2026-04-29 09:51:55,649 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:57,158 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 17 hr time horizon... +2026-04-29 09:51:57,179 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:57,913 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 9 hr time horizon... +2026-04-29 09:51:57,935 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:51:58,534 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 1 hr time horizon... +2026-04-29 09:51:58,555 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:00,469 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 18 hr time horizon... +2026-04-29 09:52:00,491 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:01,011 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 6 hr time horizon... +2026-04-29 09:52:01,037 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:01,279 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 4 hr time horizon... +2026-04-29 09:52:01,302 - __main__ - INFO - Processing values: 2018-01-05 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:02,468 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:02,494 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:02,972 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 3 hr time horizon... +2026-04-29 09:52:03,000 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:03,528 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 1 hr time horizon... +2026-04-29 09:52:03,550 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:04,290 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 4 hr time horizon... +2026-04-29 09:52:04,309 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:05,427 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 12 hr time horizon... +2026-04-29 09:52:05,452 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:06,152 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 15 hr time horizon... +2026-04-29 09:52:06,174 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:06,473 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:06,498 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:07,547 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 2 hr time horizon... +2026-04-29 09:52:07,576 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:07,978 - __main__ - INFO - Finished processing 2018-01-29 15:00:00 16 hr time horizon... +2026-04-29 09:52:08,002 - __main__ - INFO - Processing values: 2018-01-20 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:08,107 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 15 hr time horizon... +2026-04-29 09:52:08,131 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 14 hr time horizon... +2026-04-29 09:52:08,178 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 5 hr time horizon... +2026-04-29 09:52:08,199 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:10,311 - __main__ - INFO - Finished processing 2018-01-09 02:00:00 16 hr time horizon... +2026-04-29 09:52:10,340 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:11,599 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 10 hr time horizon... +2026-04-29 09:52:11,625 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:12,309 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 4 hr time horizon... +2026-04-29 09:52:12,330 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:12,508 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 8 hr time horizon... +2026-04-29 09:52:12,532 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:13,232 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 6 hr time horizon... +2026-04-29 09:52:13,258 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:14,764 - __main__ - INFO - Finished processing 2018-01-05 14:00:00 12 hr time horizon... +2026-04-29 09:52:14,786 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:15,066 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 2 hr time horizon... +2026-04-29 09:52:15,087 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:16,372 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:16,394 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:17,046 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:17,065 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:18,555 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 7 hr time horizon... +2026-04-29 09:52:18,571 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 8 hr time horizon... +2026-04-29 09:52:18,577 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 13 hr time horizon... +2026-04-29 09:52:18,594 - __main__ - INFO - Processing values: 2018-01-26 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:19,327 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 14 hr time horizon... +2026-04-29 09:52:19,351 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:20,940 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 5 hr time horizon... +2026-04-29 09:52:20,968 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:21,357 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 13 hr time horizon... +2026-04-29 09:52:21,385 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 14 hr time horizon... +2026-04-29 09:52:21,498 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:21,522 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 10 hr time horizon... +2026-04-29 09:52:21,557 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:21,587 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:22,682 - __main__ - INFO - Finished processing 2018-01-20 18:00:00 13 hr time horizon... +2026-04-29 09:52:22,710 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:23,590 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 14 hr time horizon... +2026-04-29 09:52:23,611 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:23,741 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 11 hr time horizon... +2026-04-29 09:52:23,761 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:26,155 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:52:26,179 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:26,828 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 12 hr time horizon... +2026-04-29 09:52:26,851 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:27,451 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 15 hr time horizon... +2026-04-29 09:52:27,478 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:52:28,500 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:28,530 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:28,792 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 1 hr time horizon... +2026-04-29 09:52:28,813 - __main__ - INFO - Processing values: 2018-01-12 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:28,951 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 18 hr time horizon... +2026-04-29 09:52:28,971 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:29,867 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 17 hr time horizon... +2026-04-29 09:52:29,886 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:31,516 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 16 hr time horizon... +2026-04-29 09:52:31,539 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:32,475 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 13 hr time horizon... +2026-04-29 09:52:32,497 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:32,764 - __main__ - INFO - Finished processing 2018-01-26 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:32,790 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:33,449 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 3 hr time horizon... +2026-04-29 09:52:33,469 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:34,597 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 10 hr time horizon... +2026-04-29 09:52:34,618 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:34,730 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 10 hr time horizon... +2026-04-29 09:52:34,749 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:35,734 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:35,769 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:36,610 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 8 hr time horizon... +2026-04-29 09:52:36,631 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:37,535 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 15 hr time horizon... +2026-04-29 09:52:37,560 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 5 hr time horizon... +2026-04-29 09:52:37,586 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 11 hr time horizon... +2026-04-29 09:52:37,608 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:52:38,159 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:38,185 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:40,897 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 15 hr time horizon... +2026-04-29 09:52:40,922 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:41,771 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 6 hr time horizon... +2026-04-29 09:52:41,787 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 6 hr time horizon... +2026-04-29 09:52:41,801 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:41,809 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:42,604 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 5 hr time horizon... +2026-04-29 09:52:42,628 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:43,197 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 3 hr time horizon... +2026-04-29 09:52:43,219 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:43,596 - __main__ - INFO - Finished processing 2018-01-12 15:00:00 2 hr time horizon... +2026-04-29 09:52:43,616 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:44,608 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 4 hr time horizon... +2026-04-29 09:52:44,635 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:44,844 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 5 hr time horizon... +2026-04-29 09:52:44,864 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:46,584 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 13 hr time horizon... +2026-04-29 09:52:46,606 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:46,871 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 9 hr time horizon... +2026-04-29 09:52:46,896 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:47,035 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 16 hr time horizon... +2026-04-29 09:52:47,056 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:48,038 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 2 hr time horizon... +2026-04-29 09:52:48,068 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:49,877 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 16 hr time horizon... +2026-04-29 09:52:49,900 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:50,414 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 13 hr time horizon... +2026-04-29 09:52:50,455 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:50,620 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 16 hr time horizon... +2026-04-29 09:52:50,650 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:51,624 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 5 hr time horizon... +2026-04-29 09:52:51,645 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:51,985 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 6 hr time horizon... +2026-04-29 09:52:52,003 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:52,865 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 5 hr time horizon... +2026-04-29 09:52:52,889 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 18 hr time horizon... +2026-04-29 09:52:53,222 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 15 hr time horizon... +2026-04-29 09:52:53,243 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:56,595 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 18 hr time horizon... +2026-04-29 09:52:56,619 - __main__ - INFO - Processing values: 2018-01-15 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:57,528 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 2 hr time horizon... +2026-04-29 09:52:57,556 - __main__ - INFO - Processing values: 2018-01-15 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:57,720 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 15 hr time horizon... +2026-04-29 09:52:57,743 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:57,783 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 16 hr time horizon... +2026-04-29 09:52:57,806 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 11 hr time horizon... +2026-04-29 09:52:57,821 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 4 hr time horizon... +2026-04-29 09:52:57,840 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:57,963 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 11 hr time horizon... +2026-04-29 09:52:57,981 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:59,457 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:52:59,487 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:00,391 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 9 hr time horizon... +2026-04-29 09:53:00,415 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:00,902 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 8 hr time horizon... +2026-04-29 09:53:00,933 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:02,262 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:02,294 - __main__ - INFO - Processing values: 2018-01-16 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:02,899 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 3 hr time horizon... +2026-04-29 09:53:02,924 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:03,191 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:03,212 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:04,477 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 11 hr time horizon... +2026-04-29 09:53:04,500 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:05,549 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 12 hr time horizon... +2026-04-29 09:53:05,571 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:05,976 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 7 hr time horizon... +2026-04-29 09:53:05,997 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:06,244 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 8 hr time horizon... +2026-04-29 09:53:06,276 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:06,490 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 7 hr time horizon... +2026-04-29 09:53:06,511 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:53:07,402 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:07,427 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 3 hr time horizon... +2026-04-29 09:53:08,019 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 18 hr time horizon... +2026-04-29 09:53:08,046 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:11,265 - __main__ - INFO - Finished processing 2018-01-15 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:11,299 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:11,810 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 9 hr time horizon... +2026-04-29 09:53:11,832 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:12,108 - __main__ - INFO - Finished processing 2018-01-15 17:00:00 5 hr time horizon... +2026-04-29 09:53:12,130 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:12,247 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 11 hr time horizon... +2026-04-29 09:53:12,267 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 15 hr time horizon... +2026-04-29 09:53:12,321 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 5 hr time horizon... +2026-04-29 09:53:12,340 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 9 hr time horizon... +2026-04-29 09:53:12,376 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 16 hr time horizon... +2026-04-29 09:53:12,397 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:14,393 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 17 hr time horizon... +2026-04-29 09:53:14,414 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:15,623 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 2 hr time horizon... +2026-04-29 09:53:15,646 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:17,425 - __main__ - INFO - Finished processing 2018-01-16 20:00:00 12 hr time horizon... +2026-04-29 09:53:17,446 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:17,721 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 6 hr time horizon... +2026-04-29 09:53:17,741 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:18,032 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 1 hr time horizon... +2026-04-29 09:53:18,059 - __main__ - INFO - Processing values: 2018-01-27 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:19,054 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 12 hr time horizon... +2026-04-29 09:53:19,080 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 1 hr time horizon... +2026-04-29 09:53:19,103 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:19,134 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:20,545 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 8 hr time horizon... +2026-04-29 09:53:20,568 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:20,832 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 5 hr time horizon... +2026-04-29 09:53:20,855 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:21,340 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 6 hr time horizon... +2026-04-29 09:53:21,363 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:21,636 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 7 hr time horizon... +2026-04-29 09:53:21,658 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 3 hr time horizon... +2026-04-29 09:53:22,152 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 3 hr time horizon... +2026-04-29 09:53:22,170 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:25,955 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 2 hr time horizon... +2026-04-29 09:53:25,979 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:26,021 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:26,044 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:26,687 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:26,711 - __main__ - INFO - Processing values: 2018-01-14 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:26,993 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 10 hr time horizon... +2026-04-29 09:53:27,019 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:27,429 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 11 hr time horizon... +2026-04-29 09:53:27,451 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 8 hr time horizon... +2026-04-29 09:53:27,558 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 16 hr time horizon... +2026-04-29 09:53:27,590 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 13 hr time horizon... +2026-04-29 09:53:27,657 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 15 hr time horizon... +2026-04-29 09:53:27,679 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:30,875 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 4 hr time horizon... +2026-04-29 09:53:30,903 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:32,142 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 2 hr time horizon... +2026-04-29 09:53:32,168 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:33,888 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 8 hr time horizon... +2026-04-29 09:53:33,911 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:34,078 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 1 hr time horizon... +2026-04-29 09:53:34,099 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:34,872 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:34,895 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:35,277 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:53:35,305 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:35,907 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 10 hr time horizon... +2026-04-29 09:53:35,926 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:36,146 - __main__ - INFO - Finished processing 2018-01-27 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:36,172 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:36,432 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 1 hr time horizon... +2026-04-29 09:53:36,457 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:36,781 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 5 hr time horizon... +2026-04-29 09:53:36,801 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:37,483 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 3 hr time horizon... +2026-04-29 09:53:37,506 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:38,022 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 4 hr time horizon... +2026-04-29 09:53:38,044 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:40,907 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 15 hr time horizon... +2026-04-29 09:53:40,927 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:42,127 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 13 hr time horizon... +2026-04-29 09:53:42,156 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:42,784 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 8 hr time horizon... +2026-04-29 09:53:42,809 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:42,928 - __main__ - INFO - Finished processing 2018-01-14 11:00:00 6 hr time horizon... +2026-04-29 09:53:42,948 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 5 hr time horizon... +2026-04-29 09:53:43,094 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 11 hr time horizon... +2026-04-29 09:53:43,115 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 1 hr time horizon... +2026-04-29 09:53:43,267 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 13 hr time horizon... +2026-04-29 09:53:43,291 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:43,446 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 18 hr time horizon... +2026-04-29 09:53:43,470 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:46,253 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:46,272 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:46,839 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 15 hr time horizon... +2026-04-29 09:53:46,861 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:48,829 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 4 hr time horizon... +2026-04-29 09:53:49,462 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 1 hr time horizon... +2026-04-29 09:53:49,471 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 13 hr time horizon... +2026-04-29 09:53:49,495 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:50,336 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:50,367 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:50,910 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:50,933 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:51,819 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 9 hr time horizon... +2026-04-29 09:53:51,845 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:52,382 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 7 hr time horizon... +2026-04-29 09:53:52,401 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:52,717 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:52,743 - __main__ - INFO - Processing values: 2018-01-24 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:53,305 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 2 hr time horizon... +2026-04-29 09:53:53,325 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:53,740 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 12 hr time horizon... +2026-04-29 09:53:53,768 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:53,981 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 17 hr time horizon... +2026-04-29 09:53:54,002 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:56,415 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 6 hr time horizon... +2026-04-29 09:53:56,436 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:57,896 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 14 hr time horizon... +2026-04-29 09:53:57,919 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:57,990 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 5 hr time horizon... +2026-04-29 09:53:58,010 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:58,671 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 3 hr time horizon... +2026-04-29 09:53:58,693 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:58,978 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 14 hr time horizon... +2026-04-29 09:53:59,006 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 15 hr time horizon... +2026-04-29 09:53:59,031 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 1 hr time horizon... +2026-04-29 09:53:59,054 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:53:59,546 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 16 hr time horizon... +2026-04-29 09:53:59,571 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:01,949 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 2 hr time horizon... +2026-04-29 09:54:01,968 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:03,784 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 5 hr time horizon... +2026-04-29 09:54:03,809 - __main__ - INFO - Processing values: 2018-01-02 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:04,432 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 5 hr time horizon... +2026-04-29 09:54:04,456 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:05,161 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 1 hr time horizon... +2026-04-29 09:54:05,180 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:05,825 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 1 hr time horizon... +2026-04-29 09:54:05,844 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 9 hr time horizon... +2026-04-29 09:54:05,932 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 6 hr time horizon... +2026-04-29 09:54:05,953 - __main__ - INFO - Processing values: 2018-01-04 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:06,115 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 5 hr time horizon... +2026-04-29 09:54:06,141 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:08,069 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:08,093 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:08,761 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 9 hr time horizon... +2026-04-29 09:54:08,781 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 11 hr time horizon... +2026-04-29 09:54:08,786 - __main__ - INFO - Finished processing 2018-01-24 02:00:00 12 hr time horizon... +2026-04-29 09:54:08,806 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 12 hr time horizon... +2026-04-29 09:54:08,927 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 16 hr time horizon... +2026-04-29 09:54:08,947 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:09,370 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 7 hr time horizon... +2026-04-29 09:54:09,391 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:11,624 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 10 hr time horizon... +2026-04-29 09:54:11,649 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:12,746 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 11 hr time horizon... +2026-04-29 09:54:12,767 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:12,944 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 15 hr time horizon... +2026-04-29 09:54:12,968 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:13,297 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 17 hr time horizon... +2026-04-29 09:54:13,318 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:54:13,927 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:13,962 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:14,557 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 5 hr time horizon... +2026-04-29 09:54:14,577 - __main__ - INFO - Processing values: 2018-01-13 13:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:15,387 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 18 hr time horizon... +2026-04-29 09:54:15,407 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:16,296 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 8 hr time horizon... +2026-04-29 09:54:16,316 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:18,516 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 9 hr time horizon... +2026-04-29 09:54:18,537 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:19,026 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 18 hr time horizon... +2026-04-29 09:54:19,046 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:20,472 - __main__ - INFO - Finished processing 2018-01-02 06:00:00 5 hr time horizon... +2026-04-29 09:54:20,492 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:20,617 - __main__ - INFO - Finished processing 2018-01-04 13:00:00 8 hr time horizon... +2026-04-29 09:54:20,638 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:20,718 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 9 hr time horizon... +2026-04-29 09:54:20,740 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:22,239 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:22,260 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:22,706 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:22,729 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:23,329 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 14 hr time horizon... +2026-04-29 09:54:23,353 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:24,096 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 11 hr time horizon... +2026-04-29 09:54:24,122 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:24,289 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 11 hr time horizon... +2026-04-29 09:54:24,311 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:24,999 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 12 hr time horizon... +2026-04-29 09:54:25,021 - __main__ - INFO - Processing values: 2018-01-11 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:25,922 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 10 hr time horizon... +2026-04-29 09:54:25,947 - __main__ - INFO - Processing values: 2018-01-29 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:26,617 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 1 hr time horizon... +2026-04-29 09:54:26,637 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:27,124 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 2 hr time horizon... +2026-04-29 09:54:27,149 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:27,727 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 17 hr time horizon... +2026-04-29 09:54:27,751 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:27,881 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 5 hr time horizon... +2026-04-29 09:54:27,901 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:28,387 - __main__ - INFO - Finished processing 2018-01-13 13:00:00 2 hr time horizon... +2026-04-29 09:54:28,406 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:30,474 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 6 hr time horizon... +2026-04-29 09:54:30,494 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:31,366 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 11 hr time horizon... +2026-04-29 09:54:31,395 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:33,226 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 3 hr time horizon... +2026-04-29 09:54:33,249 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:34,185 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 2 hr time horizon... +2026-04-29 09:54:34,206 - __main__ - INFO - Processing values: 2018-01-09 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:34,238 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 16 hr time horizon... +2026-04-29 09:54:34,262 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:34,572 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:34,599 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:35,136 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:35,160 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:36,839 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 10 hr time horizon... +2026-04-29 09:54:36,862 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:37,435 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 4 hr time horizon... +2026-04-29 09:54:37,460 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:38,392 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 3 hr time horizon... +2026-04-29 09:54:38,417 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:38,535 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 11 hr time horizon... +2026-04-29 09:54:38,556 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 13 hr time horizon... +2026-04-29 09:54:38,561 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 5 hr time horizon... +2026-04-29 09:54:38,584 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:39,623 - __main__ - INFO - Finished processing 2018-01-11 11:00:00 10 hr time horizon... +2026-04-29 09:54:39,652 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:40,460 - __main__ - INFO - Finished processing 2018-01-29 07:00:00 13 hr time horizon... +2026-04-29 09:54:40,484 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:41,067 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 2 hr time horizon... +2026-04-29 09:54:41,086 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:41,959 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 11 hr time horizon... +2026-04-29 09:54:41,979 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 7 hr time horizon... +2026-04-29 09:54:41,997 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 5 hr time horizon... +2026-04-29 09:54:42,025 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:42,847 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 16 hr time horizon... +2026-04-29 09:54:42,868 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:43,368 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:43,393 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:45,315 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 6 hr time horizon... +2026-04-29 09:54:45,339 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:45,921 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 9 hr time horizon... +2026-04-29 09:54:45,945 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:48,268 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 15 hr time horizon... +2026-04-29 09:54:48,287 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 12 hr time horizon... +2026-04-29 09:54:48,307 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 18 hr time horizon... +2026-04-29 09:54:48,332 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:49,443 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:49,467 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:49,619 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 15 hr time horizon... +2026-04-29 09:54:49,646 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:50,006 - __main__ - INFO - Finished processing 2018-01-09 06:00:00 17 hr time horizon... +2026-04-29 09:54:50,030 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:52,270 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 12 hr time horizon... +2026-04-29 09:54:52,293 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 3 hr time horizon... +2026-04-29 09:54:52,322 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 14 hr time horizon... +2026-04-29 09:54:52,345 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:52,469 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 18 hr time horizon... +2026-04-29 09:54:52,492 - __main__ - INFO - Processing values: 2018-01-25 00:00:00 11 hr time horizon... +2026-04-29 09:54:52,497 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 17 hr time horizon... +2026-04-29 09:54:52,522 - __main__ - INFO - Processing values: 2018-01-07 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:53,815 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:53,836 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:56,035 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:56,066 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:56,307 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 12 hr time horizon... +2026-04-29 09:54:56,327 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:57,491 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 7 hr time horizon... +2026-04-29 09:54:57,520 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:57,616 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:57,643 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:58,147 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 13 hr time horizon... +2026-04-29 09:54:58,169 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:58,375 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 3 hr time horizon... +2026-04-29 09:54:58,397 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:54:59,022 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 2 hr time horizon... +2026-04-29 09:54:59,043 - __main__ - INFO - Processing values: 2018-01-25 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:01,269 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 18 hr time horizon... +2026-04-29 09:55:01,290 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:01,881 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 14 hr time horizon... +2026-04-29 09:55:01,902 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:03,363 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:03,390 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:03,859 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 18 hr time horizon... +2026-04-29 09:55:03,879 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:04,444 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 6 hr time horizon... +2026-04-29 09:55:04,461 - __main__ - INFO - Processing values: 2018-01-20 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:04,807 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 6 hr time horizon... +2026-04-29 09:55:04,825 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:05,165 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 17 hr time horizon... +2026-04-29 09:55:05,185 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:07,031 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:07,048 - __main__ - INFO - Processing values: 2018-01-15 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:08,042 - __main__ - INFO - Finished processing 2018-01-07 23:00:00 6 hr time horizon... +2026-04-29 09:55:08,066 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 8 hr time horizon... +2026-04-29 09:55:08,071 - __main__ - INFO - Finished processing 2018-01-25 00:00:00 11 hr time horizon... +2026-04-29 09:55:08,094 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:08,969 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 10 hr time horizon... +2026-04-29 09:55:08,989 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:09,775 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 13 hr time horizon... +2026-04-29 09:55:09,800 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:10,718 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 18 hr time horizon... +2026-04-29 09:55:10,742 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:12,573 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 13 hr time horizon... +2026-04-29 09:55:12,606 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:13,094 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 3 hr time horizon... +2026-04-29 09:55:13,113 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:13,707 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 3 hr time horizon... +2026-04-29 09:55:13,734 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 8 hr time horizon... +2026-04-29 09:55:13,811 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 3 hr time horizon... +2026-04-29 09:55:13,834 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 17 hr time horizon... +2026-04-29 09:55:13,913 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:13,933 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 12 hr time horizon... +2026-04-29 09:55:14,000 - __main__ - INFO - Finished processing 2018-01-25 05:00:00 1 hr time horizon... +2026-04-29 09:55:14,016 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:16,901 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:16,924 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:17,500 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 16 hr time horizon... +2026-04-29 09:55:17,524 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:18,453 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 17 hr time horizon... +2026-04-29 09:55:18,475 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 12 hr time horizon... +2026-04-29 09:55:18,489 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 4 hr time horizon... +2026-04-29 09:55:18,507 - __main__ - INFO - Processing values: 2018-01-18 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:19,003 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 17 hr time horizon... +2026-04-29 09:55:19,029 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:19,950 - __main__ - INFO - Finished processing 2018-01-20 18:00:00 6 hr time horizon... +2026-04-29 09:55:19,972 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:20,741 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 9 hr time horizon... +2026-04-29 09:55:20,764 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 6 hr time horizon... +2026-04-29 09:55:20,880 - __main__ - INFO - Finished processing 2018-01-15 16:00:00 8 hr time horizon... +2026-04-29 09:55:20,899 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:23,567 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 8 hr time horizon... +2026-04-29 09:55:23,594 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:24,230 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 14 hr time horizon... +2026-04-29 09:55:24,254 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:24,539 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 10 hr time horizon... +2026-04-29 09:55:24,564 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:25,331 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 4 hr time horizon... +2026-04-29 09:55:25,375 - __main__ - INFO - Processing values: 2018-01-28 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:27,111 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 6 hr time horizon... +2026-04-29 09:55:27,136 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:28,594 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 13 hr time horizon... +2026-04-29 09:55:28,624 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:28,875 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 10 hr time horizon... +2026-04-29 09:55:28,900 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:29,508 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 12 hr time horizon... +2026-04-29 09:55:29,533 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:29,908 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 17 hr time horizon... +2026-04-29 09:55:29,934 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:30,039 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 8 hr time horizon... +2026-04-29 09:55:30,062 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:30,624 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 10 hr time horizon... +2026-04-29 09:55:30,647 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:33,062 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 1 hr time horizon... +2026-04-29 09:55:33,086 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 17 hr time horizon... +2026-04-29 09:55:33,202 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 13 hr time horizon... +2026-04-29 09:55:33,224 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:33,404 - __main__ - INFO - Finished processing 2018-01-18 03:00:00 1 hr time horizon... +2026-04-29 09:55:33,429 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:33,852 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 12 hr time horizon... +2026-04-29 09:55:33,874 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 7 hr time horizon... +2026-04-29 09:55:34,289 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 1 hr time horizon... +2026-04-29 09:55:34,309 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:37,481 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 14 hr time horizon... +2026-04-29 09:55:37,513 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:38,567 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 13 hr time horizon... +2026-04-29 09:55:38,589 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:38,611 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:38,636 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:39,497 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 17 hr time horizon... +2026-04-29 09:55:39,517 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 2 hr time horizon... +2026-04-29 09:55:39,570 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 3 hr time horizon... +2026-04-29 09:55:39,591 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:40,435 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 6 hr time horizon... +2026-04-29 09:55:40,455 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:41,366 - __main__ - INFO - Finished processing 2018-01-28 12:00:00 5 hr time horizon... +2026-04-29 09:55:41,387 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 13 hr time horizon... +2026-04-29 09:55:41,391 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 13 hr time horizon... +2026-04-29 09:55:41,414 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:45,745 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 8 hr time horizon... +2026-04-29 09:55:45,761 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:47,200 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 7 hr time horizon... +2026-04-29 09:55:47,218 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:51,487 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 2 hr time horizon... +2026-04-29 09:55:51,504 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:51,605 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:51,624 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:52,268 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 4 hr time horizon... +2026-04-29 09:55:52,286 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:53,005 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 17 hr time horizon... +2026-04-29 09:55:53,025 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:53,168 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:53,191 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 7 hr time horizon... +2026-04-29 09:55:53,233 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 9 hr time horizon... +2026-04-29 09:55:53,255 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 13 hr time horizon... +2026-04-29 09:55:53,366 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 12 hr time horizon... +2026-04-29 09:55:53,395 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:53,494 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 13 hr time horizon... +2026-04-29 09:55:53,520 - __main__ - INFO - Processing values: 2018-01-21 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:53,533 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 2 hr time horizon... +2026-04-29 09:55:53,551 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:54,619 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 13 hr time horizon... +2026-04-29 09:55:54,638 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 15 hr time horizon... +2026-04-29 09:55:54,771 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 10 hr time horizon... +2026-04-29 09:55:54,795 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:57,239 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 18 hr time horizon... +2026-04-29 09:55:57,264 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:58,569 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 16 hr time horizon... +2026-04-29 09:55:58,587 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:55:59,280 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 7 hr time horizon... +2026-04-29 09:55:59,297 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:04,352 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 7 hr time horizon... +2026-04-29 09:56:04,373 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:04,919 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:04,941 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:05,795 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:05,820 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:05,917 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 7 hr time horizon... +2026-04-29 09:56:05,937 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:06,130 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 13 hr time horizon... +2026-04-29 09:56:06,149 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:06,602 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 13 hr time horizon... +2026-04-29 09:56:06,622 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:06,696 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 5 hr time horizon... +2026-04-29 09:56:06,715 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:06,872 - __main__ - INFO - Finished processing 2018-01-21 05:00:00 13 hr time horizon... +2026-04-29 09:56:06,891 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:07,017 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 1 hr time horizon... +2026-04-29 09:56:07,036 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 4 hr time horizon... +2026-04-29 09:56:07,419 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 4 hr time horizon... +2026-04-29 09:56:07,433 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 9 hr time horizon... +2026-04-29 09:56:07,578 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 15 hr time horizon... +2026-04-29 09:56:07,595 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:11,705 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 11 hr time horizon... +2026-04-29 09:56:11,725 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:12,433 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 8 hr time horizon... +2026-04-29 09:56:12,452 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:12,926 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 8 hr time horizon... +2026-04-29 09:56:12,946 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:14,823 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 18 hr time horizon... +2026-04-29 09:56:14,843 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:17,446 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 12 hr time horizon... +2026-04-29 09:56:17,469 - __main__ - INFO - Processing values: 2018-01-02 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:17,719 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:17,741 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:17,842 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 3 hr time horizon... +2026-04-29 09:56:17,864 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:18,888 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:18,911 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:19,024 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:19,046 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:19,303 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:19,330 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,148 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,169 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,487 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 17 hr time horizon... +2026-04-29 09:56:20,516 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,617 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 9 hr time horizon... +2026-04-29 09:56:20,638 - __main__ - INFO - Processing values: 2018-01-17 02:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,812 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 5 hr time horizon... +2026-04-29 09:56:20,835 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:20,948 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 14 hr time horizon... +2026-04-29 09:56:20,975 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 10 hr time horizon... +2026-04-29 09:56:21,366 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 4 hr time horizon... +2026-04-29 09:56:21,391 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 14 hr time horizon... +2026-04-29 09:56:21,460 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 9 hr time horizon... +2026-04-29 09:56:21,478 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 1 hr time horizon... +2026-04-29 09:56:21,524 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 14 hr time horizon... +2026-04-29 09:56:21,543 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:25,731 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 9 hr time horizon... +2026-04-29 09:56:25,752 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:26,703 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:26,728 - __main__ - INFO - Processing values: 2018-01-19 11:00:00 3 hr time horizon... +2026-04-29 09:56:27,029 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 8 hr time horizon... +2026-04-29 09:56:27,050 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:28,780 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 18 hr time horizon... +2026-04-29 09:56:28,799 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:31,590 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 15 hr time horizon... +2026-04-29 09:56:31,617 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:31,645 - __main__ - INFO - Finished processing 2018-01-02 09:00:00 9 hr time horizon... +2026-04-29 09:56:31,666 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:32,841 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 2 hr time horizon... +2026-04-29 09:56:32,861 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:32,963 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 8 hr time horizon... +2026-04-29 09:56:32,986 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:34,504 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 2 hr time horizon... +2026-04-29 09:56:34,530 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:56:34,683 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:34,711 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:34,790 - __main__ - INFO - Finished processing 2018-01-17 02:00:00 17 hr time horizon... +2026-04-29 09:56:34,815 - __main__ - INFO - Processing values: 2018-01-13 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:34,993 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 10 hr time horizon... +2026-04-29 09:56:35,015 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:35,079 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 12 hr time horizon... +2026-04-29 09:56:35,100 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:35,276 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 11 hr time horizon... +2026-04-29 09:56:35,303 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:35,397 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 1 hr time horizon... +2026-04-29 09:56:35,423 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:35,849 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 8 hr time horizon... +2026-04-29 09:56:35,870 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 2 hr time horizon... +2026-04-29 09:56:35,916 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 14 hr time horizon... +2026-04-29 09:56:35,937 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:37,143 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 3 hr time horizon... +2026-04-29 09:56:37,164 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:40,612 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 9 hr time horizon... +2026-04-29 09:56:40,635 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:41,873 - __main__ - INFO - Finished processing 2018-01-19 11:00:00 3 hr time horizon... +2026-04-29 09:56:41,894 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 3 hr time horizon... +2026-04-29 09:56:42,093 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 18 hr time horizon... +2026-04-29 09:56:42,115 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:45,155 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 15 hr time horizon... +2026-04-29 09:56:45,176 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:45,955 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 14 hr time horizon... +2026-04-29 09:56:45,974 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:46,640 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 18 hr time horizon... +2026-04-29 09:56:46,667 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:47,557 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 6 hr time horizon... +2026-04-29 09:56:47,583 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:48,160 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 9 hr time horizon... +2026-04-29 09:56:48,182 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:49,616 - __main__ - INFO - Finished processing 2018-01-13 00:00:00 3 hr time horizon... +2026-04-29 09:56:49,636 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:49,703 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 1 hr time horizon... +2026-04-29 09:56:49,724 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:49,786 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 7 hr time horizon... +2026-04-29 09:56:49,808 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:50,314 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 7 hr time horizon... +2026-04-29 09:56:50,338 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 12 hr time horizon... +2026-04-29 09:56:50,366 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 15 hr time horizon... +2026-04-29 09:56:50,389 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:50,520 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 11 hr time horizon... +2026-04-29 09:56:50,539 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 1 hr time horizon... +2026-04-29 09:56:50,551 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 2 hr time horizon... +2026-04-29 09:56:50,572 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 1 hr time horizon... +2026-04-29 09:56:50,649 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:50,670 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:51,039 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 6 hr time horizon... +2026-04-29 09:56:51,060 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:52,574 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 12 hr time horizon... +2026-04-29 09:56:52,601 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:53,476 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 7 hr time horizon... +2026-04-29 09:56:53,502 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:55,899 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:55,928 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:57,105 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 3 hr time horizon... +2026-04-29 09:56:57,125 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:56:58,052 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 6 hr time horizon... +2026-04-29 09:56:58,078 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:01,900 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 4 hr time horizon... +2026-04-29 09:57:01,927 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 10 hr time horizon... +2026-04-29 09:57:01,958 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 11 hr time horizon... +2026-04-29 09:57:01,980 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:02,128 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 5 hr time horizon... +2026-04-29 09:57:02,149 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:02,383 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 3 hr time horizon... +2026-04-29 09:57:02,406 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:03,285 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:03,314 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:04,054 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 1 hr time horizon... +2026-04-29 09:57:04,072 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:05,536 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:05,563 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 11 hr time horizon... +2026-04-29 09:57:05,564 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 18 hr time horizon... +2026-04-29 09:57:05,592 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:05,843 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 10 hr time horizon... +2026-04-29 09:57:05,868 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:06,093 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 1 hr time horizon... +2026-04-29 09:57:06,112 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 8 hr time horizon... +2026-04-29 09:57:06,136 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 12 hr time horizon... +2026-04-29 09:57:06,160 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:06,268 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 16 hr time horizon... +2026-04-29 09:57:06,290 - __main__ - INFO - Processing values: 2018-01-04 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:06,440 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 10 hr time horizon... +2026-04-29 09:57:06,460 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:06,961 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 16 hr time horizon... +2026-04-29 09:57:06,981 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:07,722 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 5 hr time horizon... +2026-04-29 09:57:07,739 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:08,663 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 8 hr time horizon... +2026-04-29 09:57:08,686 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:11,000 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 10 hr time horizon... +2026-04-29 09:57:11,022 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:12,030 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 16 hr time horizon... +2026-04-29 09:57:12,051 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:13,713 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 17 hr time horizon... +2026-04-29 09:57:13,742 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:15,712 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 10 hr time horizon... +2026-04-29 09:57:15,735 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:16,695 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 13 hr time horizon... +2026-04-29 09:57:16,722 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:16,772 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 12 hr time horizon... +2026-04-29 09:57:16,795 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:17,214 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 15 hr time horizon... +2026-04-29 09:57:17,236 - __main__ - INFO - Processing values: 2018-01-12 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:17,677 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:17,698 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:18,166 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:18,186 - __main__ - INFO - Processing values: 2018-01-16 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:19,199 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:19,218 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:20,058 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 8 hr time horizon... +2026-04-29 09:57:20,077 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:20,633 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 4 hr time horizon... +2026-04-29 09:57:20,659 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:20,730 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:20,755 - __main__ - INFO - Processing values: 2018-01-27 20:00:00 3 hr time horizon... +2026-04-29 09:57:20,814 - __main__ - INFO - Finished processing 2018-01-04 21:00:00 10 hr time horizon... +2026-04-29 09:57:20,835 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:21,013 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:21,041 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:22,086 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 16 hr time horizon... +2026-04-29 09:57:22,108 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 4 hr time horizon... +2026-04-29 09:57:22,142 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 8 hr time horizon... +2026-04-29 09:57:22,168 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:23,414 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:23,437 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 12 hr time horizon... +2026-04-29 09:57:23,587 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 2 hr time horizon... +2026-04-29 09:57:23,609 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:25,202 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 14 hr time horizon... +2026-04-29 09:57:25,222 - __main__ - INFO - Processing values: 2018-01-03 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:26,702 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 16 hr time horizon... +2026-04-29 09:57:26,723 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:28,438 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 1 hr time horizon... +2026-04-29 09:57:28,467 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:30,379 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 9 hr time horizon... +2026-04-29 09:57:30,401 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:30,556 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:30,587 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:31,721 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 9 hr time horizon... +2026-04-29 09:57:31,741 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 16 hr time horizon... +2026-04-29 09:57:31,827 - __main__ - INFO - Finished processing 2018-01-12 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:31,858 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:32,076 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:32,100 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:32,459 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 10 hr time horizon... +2026-04-29 09:57:32,481 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:32,782 - __main__ - INFO - Finished processing 2018-01-16 18:00:00 12 hr time horizon... +2026-04-29 09:57:32,808 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:34,332 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 1 hr time horizon... +2026-04-29 09:57:34,350 - __main__ - INFO - Processing values: 2018-01-17 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:34,986 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 14 hr time horizon... +2026-04-29 09:57:35,016 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:35,030 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 3 hr time horizon... +2026-04-29 09:57:35,055 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:35,322 - __main__ - INFO - Finished processing 2018-01-27 20:00:00 3 hr time horizon... +2026-04-29 09:57:35,348 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:35,560 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 18 hr time horizon... +2026-04-29 09:57:35,586 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:37,068 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 14 hr time horizon... +2026-04-29 09:57:37,092 - __main__ - INFO - Processing values: 2018-01-22 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:37,692 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 4 hr time horizon... +2026-04-29 09:57:37,715 - __main__ - INFO - Processing values: 2018-01-28 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:37,844 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 12 hr time horizon... +2026-04-29 09:57:37,867 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:38,547 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 6 hr time horizon... +2026-04-29 09:57:38,570 - __main__ - INFO - Processing values: 2018-01-02 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:39,650 - __main__ - INFO - Finished processing 2018-01-03 06:00:00 1 hr time horizon... +2026-04-29 09:57:39,672 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:41,569 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 18 hr time horizon... +2026-04-29 09:57:41,595 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:43,840 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 18 hr time horizon... +2026-04-29 09:57:43,861 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:45,513 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 7 hr time horizon... +2026-04-29 09:57:45,535 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:45,768 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 15 hr time horizon... +2026-04-29 09:57:45,787 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:46,920 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 12 hr time horizon... +2026-04-29 09:57:46,946 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,176 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,197 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,366 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 16 hr time horizon... +2026-04-29 09:57:47,394 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,510 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,536 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:47,933 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 2 hr time horizon... +2026-04-29 09:57:47,955 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:49,760 - __main__ - INFO - Finished processing 2018-01-17 12:00:00 3 hr time horizon... +2026-04-29 09:57:49,785 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:50,100 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 1 hr time horizon... +2026-04-29 09:57:50,121 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:50,199 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 8 hr time horizon... +2026-04-29 09:57:50,220 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:50,281 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 4 hr time horizon... +2026-04-29 09:57:50,302 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:51,167 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 17 hr time horizon... +2026-04-29 09:57:51,191 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:52,839 - __main__ - INFO - Finished processing 2018-01-22 00:00:00 7 hr time horizon... +2026-04-29 09:57:52,862 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:54,054 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 12 hr time horizon... +2026-04-29 09:57:54,076 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 15 hr time horizon... +2026-04-29 09:57:54,184 - __main__ - INFO - Finished processing 2018-01-02 07:00:00 5 hr time horizon... +2026-04-29 09:57:54,203 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:54,631 - __main__ - INFO - Finished processing 2018-01-28 09:00:00 2 hr time horizon... +2026-04-29 09:57:54,652 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:56,161 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 12 hr time horizon... +2026-04-29 09:57:56,184 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:57,989 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:58,016 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:57:59,615 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 2 hr time horizon... +2026-04-29 09:57:59,639 - __main__ - INFO - Processing values: 2018-01-11 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:00,223 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 6 hr time horizon... +2026-04-29 09:58:00,246 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:01,770 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 15 hr time horizon... +2026-04-29 09:58:01,795 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:01,869 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:01,889 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:01,941 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 10 hr time horizon... +2026-04-29 09:58:01,964 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:03,490 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 13 hr time horizon... +2026-04-29 09:58:03,524 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:04,449 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:04,478 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:04,619 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:04,643 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:58:04,775 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:04,799 - __main__ - INFO - Processing values: 2018-01-30 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:05,080 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 7 hr time horizon... +2026-04-29 09:58:05,100 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 3 hr time horizon... +2026-04-29 09:58:05,112 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 12 hr time horizon... +2026-04-29 09:58:05,131 - __main__ - INFO - Processing values: 2018-01-18 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:05,211 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 2 hr time horizon... +2026-04-29 09:58:05,230 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:06,107 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 6 hr time horizon... +2026-04-29 09:58:06,134 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:07,311 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 3 hr time horizon... +2026-04-29 09:58:07,333 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:09,532 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 8 hr time horizon... +2026-04-29 09:58:09,556 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:09,815 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:09,843 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:10,394 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 9 hr time horizon... +2026-04-29 09:58:10,420 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:10,943 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:10,964 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:12,717 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 8 hr time horizon... +2026-04-29 09:58:12,738 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:15,158 - __main__ - INFO - Finished processing 2018-01-11 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:15,185 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:16,794 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 14 hr time horizon... +2026-04-29 09:58:16,820 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:17,588 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 11 hr time horizon... +2026-04-29 09:58:17,623 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:17,912 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 9 hr time horizon... +2026-04-29 09:58:17,940 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 7 hr time horizon... +2026-04-29 09:58:17,940 - __main__ - INFO - Finished processing 2018-01-07 18:00:00 12 hr time horizon... +2026-04-29 09:58:17,975 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:20,273 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 6 hr time horizon... +2026-04-29 09:58:20,302 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:20,344 - __main__ - INFO - Finished processing 2018-01-30 10:00:00 5 hr time horizon... +2026-04-29 09:58:20,364 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:20,429 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 8 hr time horizon... +2026-04-29 09:58:20,451 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 1 hr time horizon... +2026-04-29 09:58:20,739 - __main__ - INFO - Finished processing 2018-01-18 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:20,761 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:20,888 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 3 hr time horizon... +2026-04-29 09:58:20,911 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 1 hr time horizon... +2026-04-29 09:58:21,003 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 3 hr time horizon... +2026-04-29 09:58:21,026 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:22,162 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 2 hr time horizon... +2026-04-29 09:58:22,185 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:23,783 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 17 hr time horizon... +2026-04-29 09:58:23,809 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:25,735 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 16 hr time horizon... +2026-04-29 09:58:25,756 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:25,856 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 12 hr time horizon... +2026-04-29 09:58:25,881 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:26,420 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:26,453 - __main__ - INFO - Processing values: 2018-01-28 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:27,455 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 11 hr time horizon... +2026-04-29 09:58:27,477 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:29,375 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 8 hr time horizon... +2026-04-29 09:58:29,398 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:31,241 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 14 hr time horizon... +2026-04-29 09:58:31,270 - __main__ - INFO - Processing values: 2018-01-21 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:32,278 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 15 hr time horizon... +2026-04-29 09:58:32,302 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:32,603 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 12 hr time horizon... +2026-04-29 09:58:32,625 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:33,128 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 1 hr time horizon... +2026-04-29 09:58:33,148 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:33,288 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:33,309 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:33,387 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 17 hr time horizon... +2026-04-29 09:58:33,411 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:34,006 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 4 hr time horizon... +2026-04-29 09:58:34,029 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:35,556 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 1 hr time horizon... +2026-04-29 09:58:35,576 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:35,724 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 1 hr time horizon... +2026-04-29 09:58:35,743 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:36,082 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 8 hr time horizon... +2026-04-29 09:58:36,103 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:36,228 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 13 hr time horizon... +2026-04-29 09:58:36,255 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:36,875 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 16 hr time horizon... +2026-04-29 09:58:36,902 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:37,525 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 12 hr time horizon... +2026-04-29 09:58:37,548 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:40,712 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:40,739 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:41,036 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 12 hr time horizon... +2026-04-29 09:58:41,055 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:41,520 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 3 hr time horizon... +2026-04-29 09:58:41,541 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:42,469 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 1 hr time horizon... +2026-04-29 09:58:42,499 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 17 hr time horizon... +2026-04-29 09:58:42,624 - __main__ - INFO - Finished processing 2018-01-28 02:00:00 13 hr time horizon... +2026-04-29 09:58:42,648 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:45,684 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 4 hr time horizon... +2026-04-29 09:58:45,711 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:46,795 - __main__ - INFO - Finished processing 2018-01-21 02:00:00 7 hr time horizon... +2026-04-29 09:58:46,818 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:47,905 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 15 hr time horizon... +2026-04-29 09:58:47,929 - __main__ - INFO - Processing values: 2018-01-29 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:48,102 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 6 hr time horizon... +2026-04-29 09:58:48,127 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:48,386 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 18 hr time horizon... +2026-04-29 09:58:48,408 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:48,631 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 7 hr time horizon... +2026-04-29 09:58:48,654 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:49,806 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 18 hr time horizon... +2026-04-29 09:58:49,832 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:51,335 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 15 hr time horizon... +2026-04-29 09:58:51,362 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:51,665 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 9 hr time horizon... +2026-04-29 09:58:51,687 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:51,780 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 17 hr time horizon... +2026-04-29 09:58:51,803 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 16 hr time horizon... +2026-04-29 09:58:51,835 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 9 hr time horizon... +2026-04-29 09:58:51,855 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:51,968 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 8 hr time horizon... +2026-04-29 09:58:51,990 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:52,284 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 1 hr time horizon... +2026-04-29 09:58:52,302 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:53,144 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 7 hr time horizon... +2026-04-29 09:58:53,167 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:56,720 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 10 hr time horizon... +2026-04-29 09:58:56,742 - __main__ - INFO - Processing values: 2018-01-16 05:00:00 3 hr time horizon... +2026-04-29 09:58:56,745 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 12 hr time horizon... +2026-04-29 09:58:56,765 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:56,942 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 7 hr time horizon... +2026-04-29 09:58:56,963 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:57,779 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 17 hr time horizon... +2026-04-29 09:58:57,801 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:58:58,754 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 9 hr time horizon... +2026-04-29 09:58:58,776 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:01,475 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 8 hr time horizon... +2026-04-29 09:59:01,500 - __main__ - INFO - Processing values: 2018-01-06 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:01,775 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:01,805 - __main__ - INFO - Processing values: 2018-01-22 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:02,443 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:02,467 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:02,644 - __main__ - INFO - Finished processing 2018-01-29 15:00:00 11 hr time horizon... +2026-04-29 09:59:02,667 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:03,198 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 6 hr time horizon... +2026-04-29 09:59:03,224 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:03,449 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 4 hr time horizon... +2026-04-29 09:59:03,470 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:04,462 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 1 hr time horizon... +2026-04-29 09:59:04,488 - __main__ - INFO - Processing values: 2018-01-12 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:06,021 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:06,043 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:06,718 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 5 hr time horizon... +2026-04-29 09:59:06,743 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:06,930 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 16 hr time horizon... +2026-04-29 09:59:06,955 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 9 hr time horizon... +2026-04-29 09:59:06,968 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 9 hr time horizon... +2026-04-29 09:59:06,990 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:08,244 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 15 hr time horizon... +2026-04-29 09:59:08,268 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 18 hr time horizon... +2026-04-29 09:59:08,433 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 16 hr time horizon... +2026-04-29 09:59:08,456 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 14 hr time horizon... +2026-04-29 09:59:08,654 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 8 hr time horizon... +2026-04-29 09:59:08,674 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:11,897 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 4 hr time horizon... +2026-04-29 09:59:11,916 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:12,692 - __main__ - INFO - Finished processing 2018-01-16 05:00:00 3 hr time horizon... +2026-04-29 09:59:12,714 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:13,266 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 17 hr time horizon... +2026-04-29 09:59:13,287 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:14,429 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 4 hr time horizon... +2026-04-29 09:59:14,452 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:15,462 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 11 hr time horizon... +2026-04-29 09:59:15,485 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:16,939 - __main__ - INFO - Finished processing 2018-01-06 17:00:00 3 hr time horizon... +2026-04-29 09:59:16,971 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:17,440 - __main__ - INFO - Finished processing 2018-01-22 04:00:00 10 hr time horizon... +2026-04-29 09:59:17,463 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 5 hr time horizon... +2026-04-29 09:59:17,648 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:17,669 - __main__ - INFO - Processing values: 2018-01-17 20:00:00 11 hr time horizon... +2026-04-29 09:59:17,697 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:17,719 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:19,014 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 6 hr time horizon... +2026-04-29 09:59:19,036 - __main__ - INFO - Processing values: 2018-01-25 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:19,144 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 9 hr time horizon... +2026-04-29 09:59:19,167 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:20,404 - __main__ - INFO - Finished processing 2018-01-12 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:20,425 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:22,007 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 6 hr time horizon... +2026-04-29 09:59:22,036 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:22,178 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 2 hr time horizon... +2026-04-29 09:59:22,201 - __main__ - INFO - Processing values: 2018-01-16 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:22,490 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 9 hr time horizon... +2026-04-29 09:59:22,513 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:22,781 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 16 hr time horizon... +2026-04-29 09:59:22,803 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:23,488 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 2 hr time horizon... +2026-04-29 09:59:23,511 - __main__ - INFO - Processing values: 2018-01-05 12:00:00 3 hr time horizon... +2026-04-29 09:59:23,816 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 14 hr time horizon... +2026-04-29 09:59:23,842 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 5 hr time horizon... +2026-04-29 09:59:24,052 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 18 hr time horizon... +2026-04-29 09:59:24,080 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:27,029 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 14 hr time horizon... +2026-04-29 09:59:27,057 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:28,141 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 1 hr time horizon... +2026-04-29 09:59:28,163 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:28,756 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 9 hr time horizon... +2026-04-29 09:59:28,781 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:29,702 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 17 hr time horizon... +2026-04-29 09:59:29,725 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:30,557 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 1 hr time horizon... +2026-04-29 09:59:30,579 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:32,630 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:32,659 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:32,836 - __main__ - INFO - Finished processing 2018-01-17 20:00:00 11 hr time horizon... +2026-04-29 09:59:32,858 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 09:59:33,290 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:33,319 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:34,011 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 7 hr time horizon... +2026-04-29 09:59:34,035 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:34,092 - __main__ - INFO - Finished processing 2018-01-25 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:34,120 - __main__ - INFO - Processing values: 2018-01-09 23:00:00 13 hr time horizon... +2026-04-29 09:59:34,184 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 5 hr time horizon... +2026-04-29 09:59:34,210 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:36,311 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 16 hr time horizon... +2026-04-29 09:59:36,339 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:36,361 - __main__ - INFO - Finished processing 2018-01-16 13:00:00 14 hr time horizon... +2026-04-29 09:59:36,383 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:37,376 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 7 hr time horizon... +2026-04-29 09:59:37,397 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:38,189 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 6 hr time horizon... +2026-04-29 09:59:38,215 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:39,138 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 5 hr time horizon... +2026-04-29 09:59:39,167 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:39,298 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 11 hr time horizon... +2026-04-29 09:59:39,324 - __main__ - INFO - Processing values: 2018-01-27 11:00:00 16 hr time horizon... +2026-04-29 09:59:39,402 - __main__ - INFO - Finished processing 2018-01-05 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:39,430 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:40,960 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:40,996 - __main__ - INFO - Processing values: 2018-01-21 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:41,962 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 3 hr time horizon... +2026-04-29 09:59:41,983 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:43,563 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 7 hr time horizon... +2026-04-29 09:59:43,586 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:44,704 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 18 hr time horizon... +2026-04-29 09:59:44,726 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 12 hr time horizon... +2026-04-29 09:59:44,890 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 14 hr time horizon... +2026-04-29 09:59:44,913 - __main__ - INFO - Processing values: 2018-01-13 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:45,170 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 9 hr time horizon... +2026-04-29 09:59:45,191 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:47,817 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 10 hr time horizon... +2026-04-29 09:59:47,839 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:49,018 - __main__ - INFO - Finished processing 2018-01-01 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:49,044 - __main__ - INFO - Processing values: 2018-01-21 11:00:00 13 hr time horizon... +2026-04-29 09:59:49,149 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 2 hr time horizon... +2026-04-29 09:59:49,154 - __main__ - INFO - Finished processing 2018-01-09 23:00:00 13 hr time horizon... +2026-04-29 09:59:49,182 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 13 hr time horizon... +2026-04-29 09:59:49,190 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:49,256 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:49,275 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:50,941 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 14 hr time horizon... +2026-04-29 09:59:50,963 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:51,611 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 9 hr time horizon... +2026-04-29 09:59:51,637 - __main__ - INFO - Processing values: 2018-01-05 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:51,868 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 16 hr time horizon... +2026-04-29 09:59:51,893 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:53,228 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:53,254 - __main__ - INFO - Processing values: 2018-01-12 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:54,195 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:54,220 - __main__ - INFO - Processing values: 2018-01-24 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:54,695 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 3 hr time horizon... +2026-04-29 09:59:54,720 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:55,277 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 15 hr time horizon... +2026-04-29 09:59:55,301 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 7 hr time horizon... +2026-04-29 09:59:55,434 - __main__ - INFO - Finished processing 2018-01-21 07:00:00 16 hr time horizon... +2026-04-29 09:59:55,456 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:55,586 - __main__ - INFO - Finished processing 2018-01-27 11:00:00 16 hr time horizon... +2026-04-29 09:59:55,610 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:57,704 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 4 hr time horizon... +2026-04-29 09:59:57,729 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:59,021 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 1 hr time horizon... +2026-04-29 09:59:59,042 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 09:59:59,210 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 10 hr time horizon... +2026-04-29 09:59:59,229 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:00,062 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 12 hr time horizon... +2026-04-29 10:00:00,084 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 14 hr time horizon... +2026-04-29 10:00:00,147 - __main__ - INFO - Finished processing 2018-01-13 13:00:00 5 hr time horizon... +2026-04-29 10:00:00,165 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:03,154 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:03,176 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:03,974 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 9 hr time horizon... +2026-04-29 10:00:03,992 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:04,121 - __main__ - INFO - Finished processing 2018-01-21 11:00:00 13 hr time horizon... +2026-04-29 10:00:04,141 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 13 hr time horizon... +2026-04-29 10:00:04,194 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 13 hr time horizon... +2026-04-29 10:00:04,215 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:04,624 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:04,644 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 6 hr time horizon... +2026-04-29 10:00:04,705 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 2 hr time horizon... +2026-04-29 10:00:04,723 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:05,997 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 4 hr time horizon... +2026-04-29 10:00:06,017 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:06,517 - __main__ - INFO - Finished processing 2018-01-05 03:00:00 10 hr time horizon... +2026-04-29 10:00:06,539 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:07,468 - __main__ - INFO - Finished processing 2018-01-12 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:07,502 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:09,216 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 7 hr time horizon... +2026-04-29 10:00:09,243 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 18 hr time horizon... +2026-04-29 10:00:09,300 - __main__ - INFO - Finished processing 2018-01-24 08:00:00 18 hr time horizon... +2026-04-29 10:00:09,324 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:10,168 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 4 hr time horizon... +2026-04-29 10:00:10,190 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:10,635 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:10,660 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:11,254 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 1 hr time horizon... +2026-04-29 10:00:11,270 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:13,340 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 13 hr time horizon... +2026-04-29 10:00:13,367 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:13,703 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 17 hr time horizon... +2026-04-29 10:00:13,730 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:13,978 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 14 hr time horizon... +2026-04-29 10:00:14,000 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:14,708 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 14 hr time horizon... +2026-04-29 10:00:14,731 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 11 hr time horizon... +2026-04-29 10:00:15,049 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 17 hr time horizon... +2026-04-29 10:00:15,073 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:18,416 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 1 hr time horizon... +2026-04-29 10:00:18,447 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:19,069 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 3 hr time horizon... +2026-04-29 10:00:19,090 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:19,552 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 6 hr time horizon... +2026-04-29 10:00:19,579 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:19,808 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 8 hr time horizon... +2026-04-29 10:00:19,834 - __main__ - INFO - Processing values: 2018-01-21 22:00:00 5 hr time horizon... +2026-04-29 10:00:19,886 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 13 hr time horizon... +2026-04-29 10:00:19,909 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:20,122 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 2 hr time horizon... +2026-04-29 10:00:20,146 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:22,155 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 13 hr time horizon... +2026-04-29 10:00:22,176 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 18 hr time horizon... +2026-04-29 10:00:22,218 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 11 hr time horizon... +2026-04-29 10:00:22,236 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:24,684 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 18 hr time horizon... +2026-04-29 10:00:24,708 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:25,073 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:25,097 - __main__ - INFO - Processing values: 2018-01-08 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:26,019 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:26,040 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 17 hr time horizon... +2026-04-29 10:00:26,118 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 10 hr time horizon... +2026-04-29 10:00:26,142 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:26,464 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 4 hr time horizon... +2026-04-29 10:00:26,482 - __main__ - INFO - Processing values: 2018-01-01 02:00:00 4 hr time horizon... +2026-04-29 10:00:26,638 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 7 hr time horizon... +2026-04-29 10:00:26,665 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:28,665 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 7 hr time horizon... +2026-04-29 10:00:28,683 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:29,488 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 11 hr time horizon... +2026-04-29 10:00:29,507 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:29,815 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 5 hr time horizon... +2026-04-29 10:00:29,836 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:29,983 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 11 hr time horizon... +2026-04-29 10:00:30,002 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:31,705 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 6 hr time horizon... +2026-04-29 10:00:31,730 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:33,199 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 18 hr time horizon... +2026-04-29 10:00:33,228 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:33,490 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 6 hr time horizon... +2026-04-29 10:00:33,516 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:34,826 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 7 hr time horizon... +2026-04-29 10:00:34,847 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:35,155 - __main__ - INFO - Finished processing 2018-01-21 22:00:00 5 hr time horizon... +2026-04-29 10:00:35,178 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:35,283 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 2 hr time horizon... +2026-04-29 10:00:35,303 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 9 hr time horizon... +2026-04-29 10:00:35,330 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 10 hr time horizon... +2026-04-29 10:00:35,354 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:36,906 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 18 hr time horizon... +2026-04-29 10:00:36,930 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:39,989 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:40,011 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:40,446 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 17 hr time horizon... +2026-04-29 10:00:40,469 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:40,585 - __main__ - INFO - Finished processing 2018-01-01 02:00:00 4 hr time horizon... +2026-04-29 10:00:40,601 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 16 hr time horizon... +2026-04-29 10:00:40,627 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 16 hr time horizon... +2026-04-29 10:00:40,648 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:41,074 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 16 hr time horizon... +2026-04-29 10:00:41,101 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:42,803 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 17 hr time horizon... +2026-04-29 10:00:42,837 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:44,280 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 6 hr time horizon... +2026-04-29 10:00:44,298 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:44,509 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 7 hr time horizon... +2026-04-29 10:00:44,526 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:44,799 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 3 hr time horizon... +2026-04-29 10:00:44,822 - __main__ - INFO - Processing values: 2018-01-14 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:44,910 - __main__ - INFO - Finished processing 2018-01-08 21:00:00 8 hr time horizon... +2026-04-29 10:00:44,936 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:47,348 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 3 hr time horizon... +2026-04-29 10:00:47,366 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:48,165 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 6 hr time horizon... +2026-04-29 10:00:48,184 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:49,063 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 6 hr time horizon... +2026-04-29 10:00:49,082 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 11 hr time horizon... +2026-04-29 10:00:49,238 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 12 hr time horizon... +2026-04-29 10:00:49,261 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:50,942 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 7 hr time horizon... +2026-04-29 10:00:50,961 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:54,007 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 5 hr time horizon... +2026-04-29 10:00:54,031 - __main__ - INFO - Processing values: 2018-01-24 02:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:54,308 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 9 hr time horizon... +2026-04-29 10:00:54,325 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:55,179 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 9 hr time horizon... +2026-04-29 10:00:55,206 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:55,268 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 7 hr time horizon... +2026-04-29 10:00:55,286 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:55,789 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 16 hr time horizon... +2026-04-29 10:00:55,809 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:57,998 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 18 hr time horizon... +2026-04-29 10:00:58,017 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:00:59,790 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 10 hr time horizon... +2026-04-29 10:00:59,836 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:00,025 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:01:00,048 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:00,297 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 3 hr time horizon... +2026-04-29 10:01:00,318 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:01,276 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 10 hr time horizon... +2026-04-29 10:01:01,297 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:01,500 - __main__ - INFO - Finished processing 2018-01-14 12:00:00 16 hr time horizon... +2026-04-29 10:01:01,519 - __main__ - INFO - Processing values: 2018-01-19 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:02,091 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 9 hr time horizon... +2026-04-29 10:01:02,111 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:02,627 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 12 hr time horizon... +2026-04-29 10:01:02,652 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:02,922 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 11 hr time horizon... +2026-04-29 10:01:02,942 - __main__ - INFO - Processing values: 2018-01-10 22:00:00 11 hr time horizon... +2026-04-29 10:01:03,010 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 12 hr time horizon... +2026-04-29 10:01:03,030 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:04,139 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 14 hr time horizon... +2026-04-29 10:01:04,158 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:06,651 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:06,686 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:07,511 - __main__ - INFO - Finished processing 2018-01-24 02:00:00 3 hr time horizon... +2026-04-29 10:01:07,534 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:08,403 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:08,428 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 16 hr time horizon... +2026-04-29 10:01:08,465 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 15 hr time horizon... +2026-04-29 10:01:08,484 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:09,398 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 3 hr time horizon... +2026-04-29 10:01:09,418 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:10,075 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 15 hr time horizon... +2026-04-29 10:01:10,097 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:12,665 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 17 hr time horizon... +2026-04-29 10:01:12,691 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:13,687 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 7 hr time horizon... +2026-04-29 10:01:13,707 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:13,963 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 15 hr time horizon... +2026-04-29 10:01:13,993 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:14,772 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 15 hr time horizon... +2026-04-29 10:01:14,797 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:15,866 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 8 hr time horizon... +2026-04-29 10:01:15,890 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:16,944 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 4 hr time horizon... +2026-04-29 10:01:16,965 - __main__ - INFO - Processing values: 2018-01-14 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:17,234 - __main__ - INFO - Finished processing 2018-01-19 18:00:00 2 hr time horizon... +2026-04-29 10:01:17,238 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 1 hr time horizon... +2026-04-29 10:01:17,263 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 3 hr time horizon... +2026-04-29 10:01:17,265 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:17,492 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 4 hr time horizon... +2026-04-29 10:01:17,514 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:17,722 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 7 hr time horizon... +2026-04-29 10:01:17,743 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:18,208 - __main__ - INFO - Finished processing 2018-01-10 22:00:00 11 hr time horizon... +2026-04-29 10:01:18,231 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:20,278 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 8 hr time horizon... +2026-04-29 10:01:20,305 - __main__ - INFO - Processing values: 2018-01-22 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:21,567 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:21,598 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:22,752 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:22,783 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:24,488 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 16 hr time horizon... +2026-04-29 10:01:24,511 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:24,630 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 8 hr time horizon... +2026-04-29 10:01:24,650 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 6 hr time horizon... +2026-04-29 10:01:24,710 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 14 hr time horizon... +2026-04-29 10:01:24,730 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:26,013 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 3 hr time horizon... +2026-04-29 10:01:26,033 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:26,345 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 11 hr time horizon... +2026-04-29 10:01:26,367 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:28,526 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 2 hr time horizon... +2026-04-29 10:01:28,549 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:28,801 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 3 hr time horizon... +2026-04-29 10:01:28,823 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:29,744 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 13 hr time horizon... +2026-04-29 10:01:29,774 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:01:30,179 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:30,207 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:31,446 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 5 hr time horizon... +2026-04-29 10:01:31,469 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:32,262 - __main__ - INFO - Finished processing 2018-01-14 17:00:00 2 hr time horizon... +2026-04-29 10:01:32,281 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:32,483 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:32,506 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:33,239 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 15 hr time horizon... +2026-04-29 10:01:33,260 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:33,387 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 3 hr time horizon... +2026-04-29 10:01:33,410 - __main__ - INFO - Processing values: 2018-01-15 21:00:00 10 hr time horizon... +2026-04-29 10:01:33,551 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 15 hr time horizon... +2026-04-29 10:01:33,576 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:34,271 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 13 hr time horizon... +2026-04-29 10:01:34,295 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:36,899 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 18 hr time horizon... +2026-04-29 10:01:36,921 - __main__ - INFO - Processing values: 2018-01-22 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:37,863 - __main__ - INFO - Finished processing 2018-01-22 02:00:00 12 hr time horizon... +2026-04-29 10:01:37,888 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:38,033 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 6 hr time horizon... +2026-04-29 10:01:38,060 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:39,184 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 6 hr time horizon... +2026-04-29 10:01:39,202 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:39,659 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 12 hr time horizon... +2026-04-29 10:01:39,682 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:40,079 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 5 hr time horizon... +2026-04-29 10:01:40,099 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:41,012 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:41,034 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:42,283 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 9 hr time horizon... +2026-04-29 10:01:42,310 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:43,685 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 7 hr time horizon... +2026-04-29 10:01:43,709 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:44,267 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 10 hr time horizon... +2026-04-29 10:01:44,292 - __main__ - INFO - Processing values: 2018-01-09 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:45,932 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:45,954 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:46,487 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 9 hr time horizon... +2026-04-29 10:01:46,506 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:46,748 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 12 hr time horizon... +2026-04-29 10:01:46,779 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:48,603 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 6 hr time horizon... +2026-04-29 10:01:48,621 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 2 hr time horizon... +2026-04-29 10:01:48,689 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 16 hr time horizon... +2026-04-29 10:01:48,707 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:50,723 - __main__ - INFO - Finished processing 2018-01-22 14:00:00 3 hr time horizon... +2026-04-29 10:01:50,744 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:58,194 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 10 hr time horizon... +2026-04-29 10:01:58,214 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:58,642 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 2 hr time horizon... +2026-04-29 10:01:58,662 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:58,732 - __main__ - INFO - Finished processing 2018-01-09 19:00:00 18 hr time horizon... +2026-04-29 10:01:58,753 - __main__ - INFO - Processing values: 2018-01-13 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:01:58,904 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 4 hr time horizon... +2026-04-29 10:01:58,922 - __main__ - INFO - Processing values: 2018-01-05 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:00,134 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 13 hr time horizon... +2026-04-29 10:02:00,153 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:00,291 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 8 hr time horizon... +2026-04-29 10:02:00,310 - __main__ - INFO - Processing values: 2018-01-20 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:02,166 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 13 hr time horizon... +2026-04-29 10:02:02,177 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 2 hr time horizon... +2026-04-29 10:02:02,191 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 18 hr time horizon... +2026-04-29 10:02:02,205 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:03,401 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:03,421 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:04,975 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 12 hr time horizon... +2026-04-29 10:02:04,984 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 3 hr time horizon... +2026-04-29 10:02:04,998 - __main__ - INFO - Processing values: 2018-01-09 17:00:00 7 hr time horizon... +2026-04-29 10:02:05,007 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 1 hr time horizon... +2026-04-29 10:02:05,127 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 6 hr time horizon... +2026-04-29 10:02:05,152 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:08,820 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 10 hr time horizon... +2026-04-29 10:02:08,842 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:11,059 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:11,084 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:12,069 - __main__ - INFO - Finished processing 2018-01-13 05:00:00 7 hr time horizon... +2026-04-29 10:02:12,090 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:12,301 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 3 hr time horizon... +2026-04-29 10:02:12,325 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:12,790 - __main__ - INFO - Finished processing 2018-01-05 18:00:00 12 hr time horizon... +2026-04-29 10:02:12,815 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:13,356 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:13,377 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:02:13,687 - __main__ - INFO - Finished processing 2018-01-20 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:13,715 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:15,547 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 7 hr time horizon... +2026-04-29 10:02:15,573 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:15,877 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 18 hr time horizon... +2026-04-29 10:02:15,903 - __main__ - INFO - Processing values: 2018-01-02 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:15,974 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 12 hr time horizon... +2026-04-29 10:02:15,994 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 3 hr time horizon... +2026-04-29 10:02:16,044 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 18 hr time horizon... +2026-04-29 10:02:16,072 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:17,730 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 1 hr time horizon... +2026-04-29 10:02:17,748 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:18,271 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:18,296 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:18,990 - __main__ - INFO - Finished processing 2018-01-15 21:00:00 10 hr time horizon... +2026-04-29 10:02:19,010 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 9 hr time horizon... +2026-04-29 10:02:19,122 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 13 hr time horizon... +2026-04-29 10:02:19,146 - __main__ - INFO - Processing values: 2018-01-24 08:00:00 13 hr time horizon... +2026-04-29 10:02:19,605 - __main__ - INFO - Finished processing 2018-01-09 17:00:00 7 hr time horizon... +2026-04-29 10:02:19,628 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:22,743 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 13 hr time horizon... +2026-04-29 10:02:22,769 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:24,267 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 5 hr time horizon... +2026-04-29 10:02:24,287 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:26,463 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 15 hr time horizon... +2026-04-29 10:02:26,489 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:26,648 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 11 hr time horizon... +2026-04-29 10:02:26,669 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:26,930 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 13 hr time horizon... +2026-04-29 10:02:26,950 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:28,189 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 1 hr time horizon... +2026-04-29 10:02:28,208 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:28,655 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 3 hr time horizon... +2026-04-29 10:02:28,675 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 6 hr time horizon... +2026-04-29 10:02:28,974 - __main__ - INFO - Finished processing 2018-01-02 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:29,004 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:29,103 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 1 hr time horizon... +2026-04-29 10:02:29,124 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:31,159 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:31,198 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:32,031 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 8 hr time horizon... +2026-04-29 10:02:32,062 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:32,419 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 6 hr time horizon... +2026-04-29 10:02:32,440 - __main__ - INFO - Processing values: 2018-01-18 02:00:00 8 hr time horizon... +2026-04-29 10:02:32,560 - __main__ - INFO - Finished processing 2018-01-24 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:32,581 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:32,666 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 9 hr time horizon... +2026-04-29 10:02:32,687 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:33,001 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:33,019 - __main__ - INFO - Processing values: 2018-01-04 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:33,606 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 18 hr time horizon... +2026-04-29 10:02:33,629 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:35,616 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 1 hr time horizon... +2026-04-29 10:02:35,632 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:37,970 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 16 hr time horizon... +2026-04-29 10:02:37,991 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:39,951 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 18 hr time horizon... +2026-04-29 10:02:39,972 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:40,946 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 12 hr time horizon... +2026-04-29 10:02:40,971 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:41,508 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 17 hr time horizon... +2026-04-29 10:02:41,530 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:42,379 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 13 hr time horizon... +2026-04-29 10:02:42,397 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 1 hr time horizon... +2026-04-29 10:02:42,515 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 6 hr time horizon... +2026-04-29 10:02:42,536 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:42,797 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 15 hr time horizon... +2026-04-29 10:02:42,819 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 1 hr time horizon... +2026-04-29 10:02:42,925 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 6 hr time horizon... +2026-04-29 10:02:42,945 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:46,380 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 9 hr time horizon... +2026-04-29 10:02:46,409 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:47,552 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:47,579 - __main__ - INFO - Processing values: 2018-01-16 03:00:00 7 hr time horizon... +2026-04-29 10:02:47,708 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 8 hr time horizon... +2026-04-29 10:02:47,735 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:47,878 - __main__ - INFO - Finished processing 2018-01-18 02:00:00 8 hr time horizon... +2026-04-29 10:02:47,900 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:48,088 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 15 hr time horizon... +2026-04-29 10:02:48,108 - __main__ - INFO - Processing values: 2018-01-03 19:00:00 5 hr time horizon... +2026-04-29 10:02:48,224 - __main__ - INFO - Finished processing 2018-01-04 05:00:00 16 hr time horizon... +2026-04-29 10:02:48,245 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:48,353 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 12 hr time horizon... +2026-04-29 10:02:48,373 - __main__ - INFO - Processing values: 2018-01-11 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:50,608 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 5 hr time horizon... +2026-04-29 10:02:50,630 - __main__ - INFO - Processing values: 2018-01-02 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:53,564 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 6 hr time horizon... +2026-04-29 10:02:53,587 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:54,991 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:55,051 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:55,678 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:55,709 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:56,756 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:56,778 - __main__ - INFO - Processing values: 2018-01-17 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:56,930 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 13 hr time horizon... +2026-04-29 10:02:56,952 - __main__ - INFO - Processing values: 2018-01-10 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:58,201 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 1 hr time horizon... +2026-04-29 10:02:58,220 - __main__ - INFO - Processing values: 2018-01-20 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:58,416 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 14 hr time horizon... +2026-04-29 10:02:58,439 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:02:58,927 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 7 hr time horizon... +2026-04-29 10:02:58,949 - __main__ - INFO - Processing values: 2018-01-09 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:01,467 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 8 hr time horizon... +2026-04-29 10:03:01,497 - __main__ - INFO - Processing values: 2018-01-04 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:01,554 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:01,579 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 2 hr time horizon... +2026-04-29 10:03:01,734 - __main__ - INFO - Finished processing 2018-01-16 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:01,757 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 4 hr time horizon... +2026-04-29 10:03:02,026 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 17 hr time horizon... +2026-04-29 10:03:02,047 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:03:02,097 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:02,123 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 9 hr time horizon... +2026-04-29 10:03:02,167 - __main__ - INFO - Finished processing 2018-01-11 02:00:00 1 hr time horizon... +2026-04-29 10:03:02,188 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 2 hr time horizon... +2026-04-29 10:03:02,656 - __main__ - INFO - Finished processing 2018-01-03 19:00:00 5 hr time horizon... +2026-04-29 10:03:02,677 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:05,775 - __main__ - INFO - Finished processing 2018-01-02 20:00:00 18 hr time horizon... +2026-04-29 10:03:05,798 - __main__ - INFO - Processing values: 2018-01-03 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:07,379 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 3 hr time horizon... +2026-04-29 10:03:07,397 - __main__ - INFO - Processing values: 2018-01-11 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:09,456 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 3 hr time horizon... +2026-04-29 10:03:09,475 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:11,766 - __main__ - INFO - Finished processing 2018-01-17 11:00:00 3 hr time horizon... +2026-04-29 10:03:11,785 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:11,870 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 18 hr time horizon... +2026-04-29 10:03:11,894 - __main__ - INFO - Processing values: 2018-01-13 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:12,529 - __main__ - INFO - Finished processing 2018-01-10 05:00:00 8 hr time horizon... +2026-04-29 10:03:12,556 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:03:13,824 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:13,849 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:14,422 - __main__ - INFO - Finished processing 2018-01-20 11:00:00 13 hr time horizon... +2026-04-29 10:03:14,443 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 5 hr time horizon... +2026-04-29 10:03:14,534 - __main__ - INFO - Finished processing 2018-01-09 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:14,556 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:14,834 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 6 hr time horizon... +2026-04-29 10:03:14,855 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:16,151 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 2 hr time horizon... +2026-04-29 10:03:16,172 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:16,915 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 2 hr time horizon... +2026-04-29 10:03:16,935 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:17,151 - __main__ - INFO - Finished processing 2018-01-04 22:00:00 18 hr time horizon... +2026-04-29 10:03:17,177 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:17,685 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 2 hr time horizon... +2026-04-29 10:03:17,702 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:17,851 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 5 hr time horizon... +2026-04-29 10:03:17,871 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:18,261 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 9 hr time horizon... +2026-04-29 10:03:18,288 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:18,873 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 4 hr time horizon... +2026-04-29 10:03:18,893 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:20,146 - __main__ - INFO - Finished processing 2018-01-03 16:00:00 1 hr time horizon... +2026-04-29 10:03:20,164 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:22,483 - __main__ - INFO - Finished processing 2018-01-11 12:00:00 6 hr time horizon... +2026-04-29 10:03:22,505 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:24,199 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 8 hr time horizon... +2026-04-29 10:03:24,219 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:26,114 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 10 hr time horizon... +2026-04-29 10:03:26,138 - __main__ - INFO - Processing values: 2018-01-22 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:26,214 - __main__ - INFO - Finished processing 2018-01-13 06:00:00 3 hr time horizon... +2026-04-29 10:03:26,237 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:27,643 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 7 hr time horizon... +2026-04-29 10:03:27,669 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:27,888 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 4 hr time horizon... +2026-04-29 10:03:27,911 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:28,227 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 9 hr time horizon... +2026-04-29 10:03:28,247 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:28,574 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 5 hr time horizon... +2026-04-29 10:03:28,602 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:29,133 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:29,155 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:30,150 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 15 hr time horizon... +2026-04-29 10:03:30,181 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:31,480 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:31,516 - __main__ - INFO - Processing values: 2018-01-19 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:31,712 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 12 hr time horizon... +2026-04-29 10:03:31,735 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:31,916 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:31,943 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 16 hr time horizon... +2026-04-29 10:03:31,976 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 14 hr time horizon... +2026-04-29 10:03:32,002 - __main__ - INFO - Processing values: 2018-01-30 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:32,539 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 14 hr time horizon... +2026-04-29 10:03:32,563 - __main__ - INFO - Processing values: 2018-01-26 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:33,301 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 6 hr time horizon... +2026-04-29 10:03:33,321 - __main__ - INFO - Processing values: 2018-01-29 19:00:00 13 hr time horizon... +2026-04-29 10:03:33,514 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 4 hr time horizon... +2026-04-29 10:03:33,533 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:34,520 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 11 hr time horizon... +2026-04-29 10:03:34,542 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:37,323 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 12 hr time horizon... +2026-04-29 10:03:37,361 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 9 hr time horizon... +2026-04-29 10:03:37,471 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 8 hr time horizon... +2026-04-29 10:03:37,497 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:39,276 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 5 hr time horizon... +2026-04-29 10:03:39,306 - __main__ - INFO - Processing values: 2018-01-10 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:41,266 - __main__ - INFO - Finished processing 2018-01-22 12:00:00 6 hr time horizon... +2026-04-29 10:03:41,300 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:41,379 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 5 hr time horizon... +2026-04-29 10:03:41,401 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:42,383 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 13 hr time horizon... +2026-04-29 10:03:42,406 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:42,987 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 16 hr time horizon... +2026-04-29 10:03:43,007 - __main__ - INFO - Processing values: 2018-01-28 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:43,140 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 16 hr time horizon... +2026-04-29 10:03:43,163 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:43,690 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 8 hr time horizon... +2026-04-29 10:03:43,722 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:44,706 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 15 hr time horizon... +2026-04-29 10:03:44,737 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:45,268 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 6 hr time horizon... +2026-04-29 10:03:45,293 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:46,917 - __main__ - INFO - Finished processing 2018-01-19 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:46,943 - __main__ - INFO - Processing values: 2018-01-04 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:47,191 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 16 hr time horizon... +2026-04-29 10:03:47,215 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:47,498 - __main__ - INFO - Finished processing 2018-01-30 14:00:00 15 hr time horizon... +2026-04-29 10:03:47,522 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:47,955 - __main__ - INFO - Finished processing 2018-01-26 21:00:00 4 hr time horizon... +2026-04-29 10:03:47,976 - __main__ - INFO - Processing values: 2018-01-08 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:49,267 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 9 hr time horizon... +2026-04-29 10:03:49,289 - __main__ - INFO - Processing values: 2018-01-18 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:49,551 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 12 hr time horizon... +2026-04-29 10:03:49,573 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:49,763 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 15 hr time horizon... +2026-04-29 10:03:49,785 - __main__ - INFO - Processing values: 2018-01-15 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:52,496 - __main__ - INFO - Finished processing 2018-01-29 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:52,518 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:53,134 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 12 hr time horizon... +2026-04-29 10:03:53,156 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:53,738 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 9 hr time horizon... +2026-04-29 10:03:53,761 - __main__ - INFO - Processing values: 2018-01-23 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:54,280 - __main__ - INFO - Finished processing 2018-01-10 01:00:00 4 hr time horizon... +2026-04-29 10:03:54,304 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:56,912 - __main__ - INFO - Finished processing 2018-01-29 01:00:00 1 hr time horizon... +2026-04-29 10:03:56,931 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:57,127 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 11 hr time horizon... +2026-04-29 10:03:57,152 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:58,318 - __main__ - INFO - Finished processing 2018-01-28 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:58,342 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 16 hr time horizon... +2026-04-29 10:03:58,359 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 6 hr time horizon... +2026-04-29 10:03:58,381 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:03:59,231 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 9 hr time horizon... +2026-04-29 10:03:59,251 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:00,108 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 4 hr time horizon... +2026-04-29 10:04:00,126 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:01,551 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 6 hr time horizon... +2026-04-29 10:04:01,578 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:01,843 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 1 hr time horizon... +2026-04-29 10:04:01,874 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:03,313 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 15 hr time horizon... +2026-04-29 10:04:03,336 - __main__ - INFO - Processing values: 2018-01-05 02:00:00 1 hr time horizon... +2026-04-29 10:04:03,343 - __main__ - INFO - Finished processing 2018-01-04 12:00:00 10 hr time horizon... +2026-04-29 10:04:03,364 - __main__ - INFO - Processing values: 2018-01-03 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:03,467 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 6 hr time horizon... +2026-04-29 10:04:03,490 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:06,095 - __main__ - INFO - Finished processing 2018-01-18 16:00:00 1 hr time horizon... +2026-04-29 10:04:06,118 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:04:06,630 - __main__ - INFO - Finished processing 2018-01-08 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:06,658 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:07,222 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 6 hr time horizon... +2026-04-29 10:04:07,247 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:09,216 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 11 hr time horizon... +2026-04-29 10:04:09,238 - __main__ - INFO - Processing values: 2018-01-19 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:09,321 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 12 hr time horizon... +2026-04-29 10:04:09,348 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:10,167 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 1 hr time horizon... +2026-04-29 10:04:10,187 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:11,909 - __main__ - INFO - Finished processing 2018-01-15 08:00:00 5 hr time horizon... +2026-04-29 10:04:11,934 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:12,504 - __main__ - INFO - Finished processing 2018-01-23 11:00:00 15 hr time horizon... +2026-04-29 10:04:12,526 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:13,491 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 7 hr time horizon... +2026-04-29 10:04:13,521 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:13,668 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 15 hr time horizon... +2026-04-29 10:04:13,697 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:14,603 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 16 hr time horizon... +2026-04-29 10:04:14,632 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:14,676 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 8 hr time horizon... +2026-04-29 10:04:14,699 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:16,262 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:16,287 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:16,592 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 8 hr time horizon... +2026-04-29 10:04:16,616 - __main__ - INFO - Processing values: 2018-01-16 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:17,813 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 16 hr time horizon... +2026-04-29 10:04:17,815 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 17 hr time horizon... +2026-04-29 10:04:17,840 - __main__ - INFO - Processing values: 2018-01-05 09:00:00 1 hr time horizon... +2026-04-29 10:04:17,842 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:19,299 - __main__ - INFO - Finished processing 2018-01-03 10:00:00 1 hr time horizon... +2026-04-29 10:04:19,320 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:19,491 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 10 hr time horizon... +2026-04-29 10:04:19,513 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:19,908 - __main__ - INFO - Finished processing 2018-01-05 02:00:00 1 hr time horizon... +2026-04-29 10:04:19,926 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:22,224 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 5 hr time horizon... +2026-04-29 10:04:22,250 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:22,658 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 7 hr time horizon... +2026-04-29 10:04:22,679 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:22,972 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 4 hr time horizon... +2026-04-29 10:04:23,002 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:24,117 - __main__ - INFO - Finished processing 2018-01-19 05:00:00 1 hr time horizon... +2026-04-29 10:04:24,138 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:24,891 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 6 hr time horizon... +2026-04-29 10:04:24,911 - __main__ - INFO - Processing values: 2018-01-16 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:26,935 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:04:26,954 - __main__ - INFO - Processing values: 2018-01-30 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:27,080 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 2 hr time horizon... +2026-04-29 10:04:27,100 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:27,826 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 6 hr time horizon... +2026-04-29 10:04:27,853 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:30,240 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 4 hr time horizon... +2026-04-29 10:04:30,261 - __main__ - INFO - Processing values: 2018-01-26 04:00:00 17 hr time horizon... +2026-04-29 10:04:30,378 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 6 hr time horizon... +2026-04-29 10:04:30,400 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:30,497 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 6 hr time horizon... +2026-04-29 10:04:30,522 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:31,361 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 7 hr time horizon... +2026-04-29 10:04:31,409 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:33,449 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 8 hr time horizon... +2026-04-29 10:04:33,476 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:34,380 - __main__ - INFO - Finished processing 2018-01-16 15:00:00 10 hr time horizon... +2026-04-29 10:04:34,402 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:35,096 - __main__ - INFO - Finished processing 2018-01-05 09:00:00 1 hr time horizon... +2026-04-29 10:04:35,118 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:35,309 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 1 hr time horizon... +2026-04-29 10:04:35,331 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:35,795 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 15 hr time horizon... +2026-04-29 10:04:35,820 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:37,274 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 10 hr time horizon... +2026-04-29 10:04:37,295 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 15 hr time horizon... +2026-04-29 10:04:37,590 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 12 hr time horizon... +2026-04-29 10:04:37,615 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:41,411 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 12 hr time horizon... +2026-04-29 10:04:41,435 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:42,011 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 18 hr time horizon... +2026-04-29 10:04:42,039 - __main__ - INFO - Processing values: 2018-01-02 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:42,335 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:42,358 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:42,744 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 1 hr time horizon... +2026-04-29 10:04:42,766 - __main__ - INFO - Processing values: 2018-01-10 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:42,939 - __main__ - INFO - Finished processing 2018-01-16 14:00:00 4 hr time horizon... +2026-04-29 10:04:42,961 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:45,029 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 10 hr time horizon... +2026-04-29 10:04:45,046 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:45,372 - __main__ - INFO - Finished processing 2018-01-30 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:45,399 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:45,998 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 3 hr time horizon... +2026-04-29 10:04:46,019 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:47,549 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 4 hr time horizon... +2026-04-29 10:04:47,574 - __main__ - INFO - Processing values: 2018-01-27 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:47,719 - __main__ - INFO - Finished processing 2018-01-26 04:00:00 17 hr time horizon... +2026-04-29 10:04:47,751 - __main__ - INFO - Processing values: 2018-01-14 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:48,292 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 15 hr time horizon... +2026-04-29 10:04:48,318 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:48,534 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:48,557 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:50,924 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 11 hr time horizon... +2026-04-29 10:04:50,947 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:51,162 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 14 hr time horizon... +2026-04-29 10:04:51,183 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:51,664 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:51,674 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 16 hr time horizon... +2026-04-29 10:04:51,702 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:51,708 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:52,249 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 18 hr time horizon... +2026-04-29 10:04:52,271 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:53,912 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 17 hr time horizon... +2026-04-29 10:04:53,935 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:54,641 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 15 hr time horizon... +2026-04-29 10:04:54,666 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:57,332 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 17 hr time horizon... +2026-04-29 10:04:57,357 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 16 hr time horizon... +2026-04-29 10:04:57,404 - __main__ - INFO - Finished processing 2018-01-02 20:00:00 5 hr time horizon... +2026-04-29 10:04:57,427 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:57,664 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:57,691 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:58,276 - __main__ - INFO - Finished processing 2018-01-10 11:00:00 14 hr time horizon... +2026-04-29 10:04:58,299 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:04:58,620 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 18 hr time horizon... +2026-04-29 10:04:58,644 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:01,136 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:01,167 - __main__ - INFO - Processing values: 2018-01-24 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:01,257 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 5 hr time horizon... +2026-04-29 10:05:01,278 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 6 hr time horizon... +2026-04-29 10:05:01,496 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 3 hr time horizon... +2026-04-29 10:05:01,526 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:02,645 - __main__ - INFO - Finished processing 2018-01-27 02:00:00 4 hr time horizon... +2026-04-29 10:05:02,670 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:03,363 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 2 hr time horizon... +2026-04-29 10:05:03,386 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:03,872 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 14 hr time horizon... +2026-04-29 10:05:03,901 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:04,608 - __main__ - INFO - Finished processing 2018-01-14 16:00:00 11 hr time horizon... +2026-04-29 10:05:04,630 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:05,536 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 13 hr time horizon... +2026-04-29 10:05:05,561 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:06,180 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 8 hr time horizon... +2026-04-29 10:05:06,206 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:07,193 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 10 hr time horizon... +2026-04-29 10:05:07,215 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:07,354 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 15 hr time horizon... +2026-04-29 10:05:07,379 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:08,435 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:08,454 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:10,244 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 16 hr time horizon... +2026-04-29 10:05:10,267 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:10,446 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 6 hr time horizon... +2026-04-29 10:05:10,474 - __main__ - INFO - Processing values: 2018-01-21 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:12,715 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 16 hr time horizon... +2026-04-29 10:05:12,739 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:12,846 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 10 hr time horizon... +2026-04-29 10:05:12,861 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 7 hr time horizon... +2026-04-29 10:05:12,870 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 5 hr time horizon... +2026-04-29 10:05:12,887 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 1 hr time horizon... +2026-04-29 10:05:12,957 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 12 hr time horizon... +2026-04-29 10:05:12,983 - __main__ - INFO - Processing values: 2018-01-06 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:13,439 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 15 hr time horizon... +2026-04-29 10:05:13,457 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:16,192 - __main__ - INFO - Finished processing 2018-01-24 05:00:00 10 hr time horizon... +2026-04-29 10:05:16,215 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 8 hr time horizon... +2026-04-29 10:05:16,221 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 6 hr time horizon... +2026-04-29 10:05:16,245 - __main__ - INFO - Processing values: 2018-01-23 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:16,363 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 12 hr time horizon... +2026-04-29 10:05:16,384 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:17,944 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 6 hr time horizon... +2026-04-29 10:05:17,965 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:19,462 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 17 hr time horizon... +2026-04-29 10:05:19,483 - __main__ - INFO - Processing values: 2018-01-18 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:19,805 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 14 hr time horizon... +2026-04-29 10:05:19,826 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:20,363 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 13 hr time horizon... +2026-04-29 10:05:20,384 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:21,672 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:21,703 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 7 hr time horizon... +2026-04-29 10:05:21,745 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 10 hr time horizon... +2026-04-29 10:05:21,768 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:22,474 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 6 hr time horizon... +2026-04-29 10:05:22,496 - __main__ - INFO - Processing values: 2018-01-23 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:22,740 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 4 hr time horizon... +2026-04-29 10:05:22,764 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:23,455 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 3 hr time horizon... +2026-04-29 10:05:23,473 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:24,053 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 17 hr time horizon... +2026-04-29 10:05:24,074 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:25,888 - __main__ - INFO - Finished processing 2018-01-21 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:25,915 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:26,854 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 1 hr time horizon... +2026-04-29 10:05:26,873 - __main__ - INFO - Processing values: 2018-01-24 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:27,267 - __main__ - INFO - Finished processing 2018-01-06 10:00:00 4 hr time horizon... +2026-04-29 10:05:27,289 - __main__ - INFO - Processing values: 2018-01-09 11:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:27,454 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 3 hr time horizon... +2026-04-29 10:05:27,475 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 11 hr time horizon... +2026-04-29 10:05:27,652 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 5 hr time horizon... +2026-04-29 10:05:27,672 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:27,762 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:27,784 - __main__ - INFO - Processing values: 2018-01-15 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:30,425 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 8 hr time horizon... +2026-04-29 10:05:30,444 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 4 hr time horizon... +2026-04-29 10:05:30,554 - __main__ - INFO - Finished processing 2018-01-23 12:00:00 7 hr time horizon... +2026-04-29 10:05:30,575 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:30,719 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 13 hr time horizon... +2026-04-29 10:05:30,739 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:32,730 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 12 hr time horizon... +2026-04-29 10:05:32,751 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:33,290 - __main__ - INFO - Finished processing 2018-01-18 13:00:00 11 hr time horizon... +2026-04-29 10:05:33,320 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:34,913 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:34,938 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:35,555 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 14 hr time horizon... +2026-04-29 10:05:35,579 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:36,504 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 16 hr time horizon... +2026-04-29 10:05:36,526 - __main__ - INFO - Finished processing 2018-01-23 23:00:00 13 hr time horizon... +2026-04-29 10:05:36,527 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 8 hr time horizon... +2026-04-29 10:05:36,546 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:37,351 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 9 hr time horizon... +2026-04-29 10:05:37,371 - __main__ - INFO - Processing values: 2018-01-28 02:00:00 9 hr time horizon... +2026-04-29 10:05:37,548 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 14 hr time horizon... +2026-04-29 10:05:37,566 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:39,104 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 12 hr time horizon... +2026-04-29 10:05:39,129 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:40,744 - __main__ - INFO - Finished processing 2018-01-24 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:40,774 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 17 hr time horizon... +2026-04-29 10:05:40,836 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 7 hr time horizon... +2026-04-29 10:05:40,863 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:41,406 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 17 hr time horizon... +2026-04-29 10:05:41,427 - __main__ - INFO - Processing values: 2018-01-27 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:41,733 - __main__ - INFO - Finished processing 2018-01-15 11:00:00 11 hr time horizon... +2026-04-29 10:05:41,754 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:41,896 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 11 hr time horizon... +2026-04-29 10:05:41,916 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:42,235 - __main__ - INFO - Finished processing 2018-01-09 11:00:00 12 hr time horizon... +2026-04-29 10:05:42,262 - __main__ - INFO - Processing values: 2018-01-24 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:43,231 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 12 hr time horizon... +2026-04-29 10:05:43,254 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:45,145 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 13 hr time horizon... +2026-04-29 10:05:45,167 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 9 hr time horizon... +2026-04-29 10:05:45,207 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 13 hr time horizon... +2026-04-29 10:05:45,226 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:45,933 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 2 hr time horizon... +2026-04-29 10:05:45,952 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:46,438 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 4 hr time horizon... +2026-04-29 10:05:46,466 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:49,022 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 4 hr time horizon... +2026-04-29 10:05:49,043 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:49,637 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 11 hr time horizon... +2026-04-29 10:05:49,659 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:50,177 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 8 hr time horizon... +2026-04-29 10:05:50,197 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:50,370 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 8 hr time horizon... +2026-04-29 10:05:50,388 - __main__ - INFO - Processing values: 2018-01-20 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:51,448 - __main__ - INFO - Finished processing 2018-01-28 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:51,470 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 12 hr time horizon... +2026-04-29 10:05:51,803 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:51,826 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:52,016 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 7 hr time horizon... +2026-04-29 10:05:52,036 - __main__ - INFO - Processing values: 2018-01-22 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:53,376 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 7 hr time horizon... +2026-04-29 10:05:53,400 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:54,520 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 17 hr time horizon... +2026-04-29 10:05:54,543 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:54,969 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 14 hr time horizon... +2026-04-29 10:05:54,993 - __main__ - INFO - Processing values: 2018-01-21 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:55,719 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:55,740 - __main__ - INFO - Processing values: 2018-01-20 14:00:00 7 hr time horizon... +2026-04-29 10:05:55,810 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 16 hr time horizon... +2026-04-29 10:05:55,831 - __main__ - INFO - Processing values: 2018-01-22 15:00:00 11 hr time horizon... +2026-04-29 10:05:55,985 - __main__ - INFO - Finished processing 2018-01-24 02:00:00 16 hr time horizon... +2026-04-29 10:05:56,005 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:56,156 - __main__ - INFO - Finished processing 2018-01-27 19:00:00 18 hr time horizon... +2026-04-29 10:05:56,177 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:56,989 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 16 hr time horizon... +2026-04-29 10:05:57,010 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:05:59,608 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 9 hr time horizon... +2026-04-29 10:05:59,630 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 8 hr time horizon... +2026-04-29 10:05:59,838 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 17 hr time horizon... +2026-04-29 10:05:59,858 - __main__ - INFO - Processing values: 2018-01-06 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:00,151 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:01,587 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:05,122 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:05,148 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:06,134 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:06,158 - __main__ - INFO - Processing values: 2018-01-03 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:06,979 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 12 hr time horizon... +2026-04-29 10:06:07,004 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 5 hr time horizon... +2026-04-29 10:06:07,036 - __main__ - INFO - Finished processing 2018-01-22 16:00:00 12 hr time horizon... +2026-04-29 10:06:07,057 - __main__ - INFO - Processing values: 2018-01-02 17:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:07,253 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 10 hr time horizon... +2026-04-29 10:06:07,273 - __main__ - INFO - Processing values: 2018-01-07 12:00:00 6 hr time horizon... +2026-04-29 10:06:07,291 - __main__ - INFO - Finished processing 2018-01-20 12:00:00 17 hr time horizon... +2026-04-29 10:06:07,313 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:07,944 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 1 hr time horizon... +2026-04-29 10:06:07,963 - __main__ - INFO - Processing values: 2018-01-25 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:08,307 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 2 hr time horizon... +2026-04-29 10:06:08,324 - __main__ - INFO - Processing values: 2018-01-29 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:08,722 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 9 hr time horizon... +2026-04-29 10:06:08,743 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:08,886 - __main__ - INFO - Finished processing 2018-01-21 21:00:00 12 hr time horizon... +2026-04-29 10:06:08,908 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:11,036 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 1 hr time horizon... +2026-04-29 10:06:11,054 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:11,831 - __main__ - INFO - Finished processing 2018-01-20 14:00:00 7 hr time horizon... +2026-04-29 10:06:11,856 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 16 hr time horizon... +2026-04-29 10:06:12,015 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 10 hr time horizon... +2026-04-29 10:06:12,039 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:06:12,238 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:12,262 - __main__ - INFO - Processing values: 2018-01-05 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:12,985 - __main__ - INFO - Finished processing 2018-01-22 15:00:00 11 hr time horizon... +2026-04-29 10:06:13,006 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:13,212 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 11 hr time horizon... +2026-04-29 10:06:13,235 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:14,673 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 8 hr time horizon... +2026-04-29 10:06:14,691 - __main__ - INFO - Processing values: 2018-01-06 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:14,868 - __main__ - INFO - Finished processing 2018-01-06 23:00:00 3 hr time horizon... +2026-04-29 10:06:14,887 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 9 hr time horizon... +2026-04-29 10:06:15,408 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 16 hr time horizon... +2026-04-29 10:06:15,428 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:18,628 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 11 hr time horizon... +2026-04-29 10:06:18,652 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:19,634 - __main__ - INFO - Finished processing 2018-01-03 10:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:19,655 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:20,260 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 5 hr time horizon... +2026-04-29 10:06:20,282 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:21,223 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 4 hr time horizon... +2026-04-29 10:06:21,245 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:21,552 - __main__ - INFO - Finished processing 2018-01-25 15:00:00 11 hr time horizon... +2026-04-29 10:06:21,572 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:21,795 - __main__ - INFO - Finished processing 2018-01-07 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:21,819 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:22,425 - __main__ - INFO - Finished processing 2018-01-29 20:00:00 7 hr time horizon... +2026-04-29 10:06:22,447 - __main__ - INFO - Processing values: 2018-01-16 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:22,585 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 18 hr time horizon... +2026-04-29 10:06:22,604 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:23,266 - __main__ - INFO - Finished processing 2018-01-02 17:00:00 6 hr time horizon... +2026-04-29 10:06:23,290 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:25,153 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 12 hr time horizon... +2026-04-29 10:06:25,182 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:25,903 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 4 hr time horizon... +2026-04-29 10:06:25,925 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:26,394 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:26,419 - __main__ - INFO - Processing values: 2018-01-10 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:26,933 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 14 hr time horizon... +2026-04-29 10:06:26,953 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:27,111 - __main__ - INFO - Finished processing 2018-01-05 15:00:00 1 hr time horizon... +2026-04-29 10:06:27,130 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 6 hr time horizon... +2026-04-29 10:06:27,143 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 9 hr time horizon... +2026-04-29 10:06:27,164 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:28,802 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 9 hr time horizon... +2026-04-29 10:06:28,824 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:28,952 - __main__ - INFO - Finished processing 2018-01-06 15:00:00 3 hr time horizon... +2026-04-29 10:06:28,973 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:30,589 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 8 hr time horizon... +2026-04-29 10:06:30,608 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:34,232 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 9 hr time horizon... +2026-04-29 10:06:34,257 - __main__ - INFO - Processing values: 2018-01-30 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:35,029 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:35,057 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:35,729 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 11 hr time horizon... +2026-04-29 10:06:35,752 - __main__ - INFO - Processing values: 2018-01-09 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:36,047 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:36,078 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:36,209 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 5 hr time horizon... +2026-04-29 10:06:36,230 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:37,044 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 6 hr time horizon... +2026-04-29 10:06:37,069 - __main__ - INFO - Processing values: 2018-01-25 05:00:00 9 hr time horizon... +2026-04-29 10:06:37,170 - __main__ - INFO - Finished processing 2018-01-16 04:00:00 6 hr time horizon... +2026-04-29 10:06:37,193 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:37,302 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 1 hr time horizon... +2026-04-29 10:06:37,320 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:37,660 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 16 hr time horizon... +2026-04-29 10:06:37,684 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:37,851 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:37,876 - __main__ - INFO - Processing values: 2018-01-30 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:39,553 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 17 hr time horizon... +2026-04-29 10:06:39,575 - __main__ - INFO - Processing values: 2018-01-25 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:40,831 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:40,852 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:41,993 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:42,017 - __main__ - INFO - Processing values: 2018-01-04 13:00:00 12 hr time horizon... +2026-04-29 10:06:42,025 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 6 hr time horizon... +2026-04-29 10:06:42,048 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:42,496 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 1 hr time horizon... +2026-04-29 10:06:42,514 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:43,664 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 5 hr time horizon... +2026-04-29 10:06:43,685 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:45,355 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 5 hr time horizon... +2026-04-29 10:06:45,380 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:46,137 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 14 hr time horizon... +2026-04-29 10:06:46,158 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:49,808 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 7 hr time horizon... +2026-04-29 10:06:49,830 - __main__ - INFO - Processing values: 2018-01-23 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:51,036 - __main__ - INFO - Finished processing 2018-01-30 01:00:00 12 hr time horizon... +2026-04-29 10:06:51,061 - __main__ - INFO - Processing values: 2018-01-22 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:51,279 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:51,302 - __main__ - INFO - Processing values: 2018-01-14 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:51,800 - __main__ - INFO - Finished processing 2018-01-09 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:51,824 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:52,458 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 15 hr time horizon... +2026-04-29 10:06:52,475 - __main__ - INFO - Finished processing 2018-01-25 05:00:00 9 hr time horizon... +2026-04-29 10:06:52,479 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 10 hr time horizon... +2026-04-29 10:06:52,495 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:52,804 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 14 hr time horizon... +2026-04-29 10:06:52,849 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:54,186 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 12 hr time horizon... +2026-04-29 10:06:54,216 - __main__ - INFO - Processing values: 2018-01-13 18:00:00 10 hr time horizon... +2026-04-29 10:06:54,330 - __main__ - INFO - Finished processing 2018-01-25 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:54,353 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 18 hr time horizon... +2026-04-29 10:06:54,408 - __main__ - INFO - Finished processing 2018-01-10 09:00:00 3 hr time horizon... +2026-04-29 10:06:54,430 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:55,201 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 4 hr time horizon... +2026-04-29 10:06:55,219 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:56,708 - __main__ - INFO - Finished processing 2018-01-30 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:56,734 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:57,488 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:57,512 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:57,930 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 15 hr time horizon... +2026-04-29 10:06:57,953 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:58,099 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 15 hr time horizon... +2026-04-29 10:06:58,122 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:06:58,620 - __main__ - INFO - Finished processing 2018-01-04 13:00:00 12 hr time horizon... +2026-04-29 10:06:58,644 - __main__ - INFO - Processing values: 2018-01-24 17:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:00,073 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 17 hr time horizon... +2026-04-29 10:07:00,095 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:01,797 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 1 hr time horizon... +2026-04-29 10:07:01,818 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:02,174 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 3 hr time horizon... +2026-04-29 10:07:02,199 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:05,017 - __main__ - INFO - Finished processing 2018-01-23 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:05,038 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:05,947 - __main__ - INFO - Finished processing 2018-01-14 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:05,973 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:06,600 - __main__ - INFO - Finished processing 2018-01-22 18:00:00 14 hr time horizon... +2026-04-29 10:07:06,629 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:06,955 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 2 hr time horizon... +2026-04-29 10:07:06,975 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:08,036 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:08,060 - __main__ - INFO - Processing values: 2018-01-03 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:08,820 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 10 hr time horizon... +2026-04-29 10:07:08,849 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 4 hr time horizon... +2026-04-29 10:07:08,870 - __main__ - INFO - Finished processing 2018-01-13 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:08,895 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:09,423 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 1 hr time horizon... +2026-04-29 10:07:09,443 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:10,029 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 18 hr time horizon... +2026-04-29 10:07:10,068 - __main__ - INFO - Processing values: 2018-01-24 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:10,704 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 7 hr time horizon... +2026-04-29 10:07:10,732 - __main__ - INFO - Processing values: 2018-01-21 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:12,226 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 3 hr time horizon... +2026-04-29 10:07:12,248 - __main__ - INFO - Processing values: 2018-01-26 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:12,576 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 3 hr time horizon... +2026-04-29 10:07:12,596 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 15 hr time horizon... +2026-04-29 10:07:12,732 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:12,751 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:13,396 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 18 hr time horizon... +2026-04-29 10:07:13,420 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 14 hr time horizon... +2026-04-29 10:07:13,592 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 7 hr time horizon... +2026-04-29 10:07:13,618 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:13,752 - __main__ - INFO - Finished processing 2018-01-24 17:00:00 16 hr time horizon... +2026-04-29 10:07:13,774 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:16,289 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 15 hr time horizon... +2026-04-29 10:07:16,314 - __main__ - INFO - Processing values: 2018-01-13 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:17,219 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:17,240 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:17,846 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 14 hr time horizon... +2026-04-29 10:07:17,870 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:19,902 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 13 hr time horizon... +2026-04-29 10:07:19,926 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:20,876 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 1 hr time horizon... +2026-04-29 10:07:20,900 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:22,066 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 1 hr time horizon... +2026-04-29 10:07:22,092 - __main__ - INFO - Processing values: 2018-01-16 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:23,608 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 4 hr time horizon... +2026-04-29 10:07:23,627 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:23,857 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 7 hr time horizon... +2026-04-29 10:07:23,891 - __main__ - INFO - Processing values: 2018-01-25 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:24,651 - __main__ - INFO - Finished processing 2018-01-24 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:24,673 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:24,791 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 7 hr time horizon... +2026-04-29 10:07:24,816 - __main__ - INFO - Processing values: 2018-01-26 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:24,918 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 3 hr time horizon... +2026-04-29 10:07:24,940 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:25,384 - __main__ - INFO - Finished processing 2018-01-03 10:00:00 10 hr time horizon... +2026-04-29 10:07:25,413 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:25,848 - __main__ - INFO - Finished processing 2018-01-21 01:00:00 16 hr time horizon... +2026-04-29 10:07:25,871 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:27,145 - __main__ - INFO - Finished processing 2018-01-26 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:27,168 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:28,290 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 15 hr time horizon... +2026-04-29 10:07:28,313 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:28,551 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 14 hr time horizon... +2026-04-29 10:07:28,575 - __main__ - INFO - Processing values: 2018-01-17 17:00:00 14 hr time horizon... +2026-04-29 10:07:28,580 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 5 hr time horizon... +2026-04-29 10:07:28,601 - __main__ - INFO - Processing values: 2018-01-19 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:31,165 - __main__ - INFO - Finished processing 2018-01-13 06:00:00 13 hr time horizon... +2026-04-29 10:07:31,186 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 16 hr time horizon... +2026-04-29 10:07:31,241 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:31,266 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:31,740 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 10 hr time horizon... +2026-04-29 10:07:31,766 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 8 hr time horizon... +2026-04-29 10:07:31,938 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:07:31,960 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:33,018 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 11 hr time horizon... +2026-04-29 10:07:33,040 - __main__ - INFO - Processing values: 2018-01-20 06:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:35,052 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 9 hr time horizon... +2026-04-29 10:07:35,077 - __main__ - INFO - Processing values: 2018-01-30 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:36,445 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 17 hr time horizon... +2026-04-29 10:07:36,469 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:37,421 - __main__ - INFO - Finished processing 2018-01-16 01:00:00 6 hr time horizon... +2026-04-29 10:07:37,443 - __main__ - INFO - Processing values: 2018-01-30 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:38,160 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 16 hr time horizon... +2026-04-29 10:07:38,184 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:39,255 - __main__ - INFO - Finished processing 2018-01-25 10:00:00 3 hr time horizon... +2026-04-29 10:07:39,277 - __main__ - INFO - Processing values: 2018-01-23 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:39,990 - __main__ - INFO - Finished processing 2018-01-26 16:00:00 14 hr time horizon... +2026-04-29 10:07:40,023 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:40,175 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 8 hr time horizon... +2026-04-29 10:07:40,197 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:40,620 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 17 hr time horizon... +2026-04-29 10:07:40,646 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:40,872 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 8 hr time horizon... +2026-04-29 10:07:40,890 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:41,457 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 13 hr time horizon... +2026-04-29 10:07:41,480 - __main__ - INFO - Processing values: 2018-01-11 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:42,211 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 16 hr time horizon... +2026-04-29 10:07:42,234 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:45,545 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 3 hr time horizon... +2026-04-29 10:07:45,567 - __main__ - INFO - Processing values: 2018-01-21 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:45,983 - __main__ - INFO - Finished processing 2018-01-19 09:00:00 2 hr time horizon... +2026-04-29 10:07:46,006 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:46,779 - __main__ - INFO - Finished processing 2018-01-17 17:00:00 14 hr time horizon... +2026-04-29 10:07:46,805 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:49,133 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 16 hr time horizon... +2026-04-29 10:07:49,154 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 14 hr time horizon... +2026-04-29 10:07:49,243 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 8 hr time horizon... +2026-04-29 10:07:49,262 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:49,686 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 14 hr time horizon... +2026-04-29 10:07:49,710 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:50,378 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 13 hr time horizon... +2026-04-29 10:07:50,403 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:52,995 - __main__ - INFO - Finished processing 2018-01-30 16:00:00 11 hr time horizon... +2026-04-29 10:07:53,017 - __main__ - INFO - Processing values: 2018-01-05 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:53,925 - __main__ - INFO - Finished processing 2018-01-20 06:00:00 13 hr time horizon... +2026-04-29 10:07:53,954 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:54,516 - __main__ - INFO - Finished processing 2018-01-30 08:00:00 1 hr time horizon... +2026-04-29 10:07:54,535 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:55,701 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 12 hr time horizon... +2026-04-29 10:07:55,724 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:55,835 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 11 hr time horizon... +2026-04-29 10:07:55,860 - __main__ - INFO - Processing values: 2018-01-24 22:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:56,393 - __main__ - INFO - Finished processing 2018-01-23 20:00:00 8 hr time horizon... +2026-04-29 10:07:56,414 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:56,878 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 4 hr time horizon... +2026-04-29 10:07:56,901 - __main__ - INFO - Processing values: 2018-01-23 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:57,117 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 1 hr time horizon... +2026-04-29 10:07:57,135 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:57,321 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 15 hr time horizon... +2026-04-29 10:07:57,347 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:58,188 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 14 hr time horizon... +2026-04-29 10:07:58,210 - __main__ - INFO - Processing values: 2018-01-26 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:59,894 - __main__ - INFO - Finished processing 2018-01-11 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:07:59,918 - __main__ - INFO - Processing values: 2018-01-27 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:00,509 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:00,537 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:01,143 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 3 hr time horizon... +2026-04-29 10:08:01,162 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:01,731 - __main__ - INFO - Finished processing 2018-01-21 16:00:00 15 hr time horizon... +2026-04-29 10:08:01,735 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 12 hr time horizon... +2026-04-29 10:08:01,759 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 9 hr time horizon... +2026-04-29 10:08:01,760 - __main__ - INFO - Processing values: 2018-01-15 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:04,134 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:04,156 - __main__ - INFO - Processing values: 2018-01-27 23:00:00 4 hr time horizon... +2026-04-29 10:08:04,318 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 13 hr time horizon... +2026-04-29 10:08:04,335 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:05,550 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 16 hr time horizon... +2026-04-29 10:08:05,572 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:07,865 - __main__ - INFO - Finished processing 2018-01-05 06:00:00 16 hr time horizon... +2026-04-29 10:08:07,885 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:08,056 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 14 hr time horizon... +2026-04-29 10:08:08,069 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 2 hr time horizon... +2026-04-29 10:08:08,082 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 8 hr time horizon... +2026-04-29 10:08:08,093 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:09,142 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 18 hr time horizon... +2026-04-29 10:08:09,170 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:09,347 - __main__ - INFO - Finished processing 2018-01-24 22:00:00 1 hr time horizon... +2026-04-29 10:08:09,364 - __main__ - INFO - Processing values: 2018-01-21 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:11,219 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 3 hr time horizon... +2026-04-29 10:08:11,238 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 6 hr time horizon... +2026-04-29 10:08:11,253 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:11,276 - __main__ - INFO - Processing values: 2018-01-18 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:11,327 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 3 hr time horizon... +2026-04-29 10:08:11,347 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 18 hr time horizon... +2026-04-29 10:08:11,391 - __main__ - INFO - Finished processing 2018-01-23 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:11,412 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:11,938 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 15 hr time horizon... +2026-04-29 10:08:11,960 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:12,619 - __main__ - INFO - Finished processing 2018-01-26 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:12,641 - __main__ - INFO - Processing values: 2018-01-08 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:14,399 - __main__ - INFO - Finished processing 2018-01-27 04:00:00 17 hr time horizon... +2026-04-29 10:08:14,423 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:15,828 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:15,854 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:16,121 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 14 hr time horizon... +2026-04-29 10:08:16,146 - __main__ - INFO - Processing values: 2018-01-01 16:00:00 8 hr time horizon... +2026-04-29 10:08:16,177 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 3 hr time horizon... +2026-04-29 10:08:16,202 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:16,292 - __main__ - INFO - Finished processing 2018-01-15 07:00:00 13 hr time horizon... +2026-04-29 10:08:16,312 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:18,323 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 2 hr time horizon... +2026-04-29 10:08:18,342 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:18,912 - __main__ - INFO - Finished processing 2018-01-27 23:00:00 4 hr time horizon... +2026-04-29 10:08:18,933 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:20,785 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 15 hr time horizon... +2026-04-29 10:08:20,810 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:22,129 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:22,150 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:22,258 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:22,279 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:22,711 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 15 hr time horizon... +2026-04-29 10:08:22,743 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:23,090 - __main__ - INFO - Finished processing 2018-01-21 17:00:00 13 hr time horizon... +2026-04-29 10:08:23,113 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:23,280 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 10 hr time horizon... +2026-04-29 10:08:23,301 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:24,773 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 6 hr time horizon... +2026-04-29 10:08:24,792 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:25,416 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 18 hr time horizon... +2026-04-29 10:08:25,435 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:25,770 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 17 hr time horizon... +2026-04-29 10:08:25,793 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 13 hr time horizon... +2026-04-29 10:08:25,927 - __main__ - INFO - Finished processing 2018-01-18 07:00:00 18 hr time horizon... +2026-04-29 10:08:25,949 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:26,653 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 6 hr time horizon... +2026-04-29 10:08:26,674 - __main__ - INFO - Processing values: 2018-01-24 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:08:26,782 - __main__ - INFO - Finished processing 2018-01-08 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:26,821 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:28,521 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 10 hr time horizon... +2026-04-29 10:08:28,542 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:30,211 - __main__ - INFO - Finished processing 2018-01-01 16:00:00 8 hr time horizon... +2026-04-29 10:08:30,230 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:30,506 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 4 hr time horizon... +2026-04-29 10:08:30,526 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:31,069 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 12 hr time horizon... +2026-04-29 10:08:31,092 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:32,819 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 2 hr time horizon... +2026-04-29 10:08:32,841 - __main__ - INFO - Processing values: 2018-01-07 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:33,922 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 7 hr time horizon... +2026-04-29 10:08:33,945 - __main__ - INFO - Processing values: 2018-01-03 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:35,375 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 16 hr time horizon... +2026-04-29 10:08:35,401 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:35,638 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 15 hr time horizon... +2026-04-29 10:08:35,666 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:37,489 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 11 hr time horizon... +2026-04-29 10:08:37,503 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 18 hr time horizon... +2026-04-29 10:08:37,509 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 6 hr time horizon... +2026-04-29 10:08:37,527 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:37,740 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 6 hr time horizon... +2026-04-29 10:08:37,765 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:38,847 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 13 hr time horizon... +2026-04-29 10:08:38,870 - __main__ - INFO - Processing values: 2018-01-20 18:00:00 2 hr time horizon... +2026-04-29 10:08:38,875 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:38,902 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:39,323 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 1 hr time horizon... +2026-04-29 10:08:39,341 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:40,831 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 15 hr time horizon... +2026-04-29 10:08:40,853 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:41,083 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 13 hr time horizon... +2026-04-29 10:08:41,105 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:41,987 - __main__ - INFO - Finished processing 2018-01-24 03:00:00 3 hr time horizon... +2026-04-29 10:08:42,008 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 6 hr time horizon... +2026-04-29 10:08:42,086 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 7 hr time horizon... +2026-04-29 10:08:42,107 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 13 hr time horizon... +2026-04-29 10:08:42,146 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 3 hr time horizon... +2026-04-29 10:08:42,168 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:44,144 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 18 hr time horizon... +2026-04-29 10:08:44,167 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:46,268 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 7 hr time horizon... +2026-04-29 10:08:46,291 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 11 hr time horizon... +2026-04-29 10:08:46,313 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 4 hr time horizon... +2026-04-29 10:08:46,342 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:46,884 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 15 hr time horizon... +2026-04-29 10:08:46,911 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:48,129 - __main__ - INFO - Finished processing 2018-01-07 17:00:00 7 hr time horizon... +2026-04-29 10:08:48,157 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:49,712 - __main__ - INFO - Finished processing 2018-01-03 02:00:00 10 hr time horizon... +2026-04-29 10:08:49,740 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:50,494 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 5 hr time horizon... +2026-04-29 10:08:50,514 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:52,663 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:52,686 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:52,798 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 10 hr time horizon... +2026-04-29 10:08:52,819 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:53,346 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 1 hr time horizon... +2026-04-29 10:08:53,367 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:53,949 - __main__ - INFO - Finished processing 2018-01-20 18:00:00 2 hr time horizon... +2026-04-29 10:08:53,983 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:54,954 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 8 hr time horizon... +2026-04-29 10:08:54,980 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:56,024 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:56,057 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:56,183 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 6 hr time horizon... +2026-04-29 10:08:56,211 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:56,782 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 9 hr time horizon... +2026-04-29 10:08:56,807 - __main__ - INFO - Processing values: 2018-01-07 16:00:00 7 hr time horizon... +2026-04-29 10:08:56,809 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 12 hr time horizon... +2026-04-29 10:08:56,839 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:57,367 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 6 hr time horizon... +2026-04-29 10:08:57,388 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:57,635 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 16 hr time horizon... +2026-04-29 10:08:57,655 - __main__ - INFO - Processing values: 2018-01-11 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:08:58,186 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 13 hr time horizon... +2026-04-29 10:08:58,209 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:00,575 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 17 hr time horizon... +2026-04-29 10:09:00,596 - __main__ - INFO - Processing values: 2018-01-06 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:01,054 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 11 hr time horizon... +2026-04-29 10:09:01,077 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:02,031 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 18 hr time horizon... +2026-04-29 10:09:02,053 - __main__ - INFO - Processing values: 2018-01-13 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:02,160 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 10 hr time horizon... +2026-04-29 10:09:02,182 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:04,243 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:04,265 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:04,884 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:04,912 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:05,219 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 13 hr time horizon... +2026-04-29 10:09:05,244 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:06,677 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:06,707 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:07,848 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 3 hr time horizon... +2026-04-29 10:09:07,871 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 1 hr time horizon... +2026-04-29 10:09:07,877 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 14 hr time horizon... +2026-04-29 10:09:07,898 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:08,025 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 11 hr time horizon... +2026-04-29 10:09:08,048 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:09,395 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 11 hr time horizon... +2026-04-29 10:09:09,417 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:09,651 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:09,671 - __main__ - INFO - Processing values: 2018-01-01 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:10,254 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 2 hr time horizon... +2026-04-29 10:09:10,279 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:11,136 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:11,168 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:11,664 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 8 hr time horizon... +2026-04-29 10:09:11,683 - __main__ - INFO - Processing values: 2018-01-09 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:12,173 - __main__ - INFO - Finished processing 2018-01-07 16:00:00 7 hr time horizon... +2026-04-29 10:09:12,197 - __main__ - INFO - Processing values: 2018-01-02 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:12,755 - __main__ - INFO - Finished processing 2018-01-11 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:09:12,778 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:12,876 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 4 hr time horizon... +2026-04-29 10:09:12,900 - __main__ - INFO - Processing values: 2018-01-20 17:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:15,433 - __main__ - INFO - Finished processing 2018-01-06 07:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:15,459 - __main__ - INFO - Processing values: 2018-01-25 09:00:00 8 hr time horizon... +2026-04-29 10:09:15,628 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 13 hr time horizon... +2026-04-29 10:09:15,649 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:16,465 - __main__ - INFO - Finished processing 2018-01-13 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:16,485 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:17,421 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 8 hr time horizon... +2026-04-29 10:09:17,444 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:18,630 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 8 hr time horizon... +2026-04-29 10:09:18,652 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:20,333 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 5 hr time horizon... +2026-04-29 10:09:20,355 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:20,834 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:20,857 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:21,356 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 5 hr time horizon... +2026-04-29 10:09:21,374 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:22,494 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 1 hr time horizon... +2026-04-29 10:09:22,513 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:22,824 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 3 hr time horizon... +2026-04-29 10:09:22,847 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:23,436 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:23,466 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:23,885 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 11 hr time horizon... +2026-04-29 10:09:23,910 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:24,899 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:24,926 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:25,459 - __main__ - INFO - Finished processing 2018-01-01 03:00:00 5 hr time horizon... +2026-04-29 10:09:25,480 - __main__ - INFO - Processing values: 2018-01-28 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:25,641 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 17 hr time horizon... +2026-04-29 10:09:25,664 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:26,786 - __main__ - INFO - Finished processing 2018-01-09 22:00:00 2 hr time horizon... +2026-04-29 10:09:26,807 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 4 hr time horizon... +2026-04-29 10:09:26,811 - __main__ - INFO - Finished processing 2018-01-20 17:00:00 1 hr time horizon... +2026-04-29 10:09:26,829 - __main__ - INFO - Processing values: 2018-01-20 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:27,269 - __main__ - INFO - Finished processing 2018-01-02 17:00:00 12 hr time horizon... +2026-04-29 10:09:27,292 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 9 hr time horizon... +2026-04-29 10:09:27,458 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 4 hr time horizon... +2026-04-29 10:09:27,475 - __main__ - INFO - Processing values: 2018-01-14 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:30,231 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 2 hr time horizon... +2026-04-29 10:09:30,254 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:30,625 - __main__ - INFO - Finished processing 2018-01-25 09:00:00 8 hr time horizon... +2026-04-29 10:09:30,647 - __main__ - INFO - Processing values: 2018-01-20 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:32,330 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 7 hr time horizon... +2026-04-29 10:09:32,355 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:33,562 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 5 hr time horizon... +2026-04-29 10:09:33,581 - __main__ - INFO - Processing values: 2018-01-03 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:33,713 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 13 hr time horizon... +2026-04-29 10:09:33,740 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:34,153 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 16 hr time horizon... +2026-04-29 10:09:34,182 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:36,035 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:36,060 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:36,786 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 18 hr time horizon... +2026-04-29 10:09:36,806 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:37,118 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:37,147 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:37,895 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 5 hr time horizon... +2026-04-29 10:09:37,919 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:38,417 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 4 hr time horizon... +2026-04-29 10:09:38,445 - __main__ - INFO - Processing values: 2018-01-27 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:38,648 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 4 hr time horizon... +2026-04-29 10:09:38,679 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:40,457 - __main__ - INFO - Finished processing 2018-01-28 12:00:00 10 hr time horizon... +2026-04-29 10:09:40,482 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:09:40,730 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:40,764 - __main__ - INFO - Processing values: 2018-01-26 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:41,222 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 12 hr time horizon... +2026-04-29 10:09:41,243 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:41,994 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 4 hr time horizon... +2026-04-29 10:09:42,017 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:42,540 - __main__ - INFO - Finished processing 2018-01-20 08:00:00 17 hr time horizon... +2026-04-29 10:09:42,567 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:43,021 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 9 hr time horizon... +2026-04-29 10:09:43,047 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:43,754 - __main__ - INFO - Finished processing 2018-01-14 00:00:00 12 hr time horizon... +2026-04-29 10:09:43,777 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:45,983 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 2 hr time horizon... +2026-04-29 10:09:46,006 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:46,214 - __main__ - INFO - Finished processing 2018-01-20 00:00:00 13 hr time horizon... +2026-04-29 10:09:46,241 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:48,257 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 9 hr time horizon... +2026-04-29 10:09:48,281 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:49,019 - __main__ - INFO - Finished processing 2018-01-03 01:00:00 3 hr time horizon... +2026-04-29 10:09:49,041 - __main__ - INFO - Processing values: 2018-01-13 16:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:49,160 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 18 hr time horizon... +2026-04-29 10:09:49,183 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:49,690 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 17 hr time horizon... +2026-04-29 10:09:49,713 - __main__ - INFO - Processing values: 2018-01-01 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:52,017 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 2 hr time horizon... +2026-04-29 10:09:52,037 - __main__ - INFO - Processing values: 2018-01-05 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:52,375 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 15 hr time horizon... +2026-04-29 10:09:52,398 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:53,110 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 14 hr time horizon... +2026-04-29 10:09:53,141 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:53,717 - __main__ - INFO - Finished processing 2018-01-27 00:00:00 16 hr time horizon... +2026-04-29 10:09:53,743 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:53,878 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 3 hr time horizon... +2026-04-29 10:09:53,909 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:54,347 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 17 hr time horizon... +2026-04-29 10:09:54,372 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:55,821 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 12 hr time horizon... +2026-04-29 10:09:55,844 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 17 hr time horizon... +2026-04-29 10:09:56,046 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:56,070 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:56,286 - __main__ - INFO - Finished processing 2018-01-26 15:00:00 14 hr time horizon... +2026-04-29 10:09:56,308 - __main__ - INFO - Processing values: 2018-01-04 22:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:56,738 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 13 hr time horizon... +2026-04-29 10:09:56,761 - __main__ - INFO - Processing values: 2018-01-22 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:58,642 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 9 hr time horizon... +2026-04-29 10:09:58,663 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:09:59,526 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 14 hr time horizon... +2026-04-29 10:09:59,551 - __main__ - INFO - Processing values: 2018-01-26 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:00,074 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 4 hr time horizon... +2026-04-29 10:10:00,097 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:02,012 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 3 hr time horizon... +2026-04-29 10:10:02,035 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:02,524 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 4 hr time horizon... +2026-04-29 10:10:02,546 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:02,938 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 16 hr time horizon... +2026-04-29 10:10:02,963 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:04,235 - __main__ - INFO - Finished processing 2018-01-13 16:00:00 8 hr time horizon... +2026-04-29 10:10:04,258 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:04,918 - __main__ - INFO - Finished processing 2018-01-01 17:00:00 17 hr time horizon... +2026-04-29 10:10:04,937 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:05,262 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 10 hr time horizon... +2026-04-29 10:10:05,285 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:07,298 - __main__ - INFO - Finished processing 2018-01-05 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:07,320 - __main__ - INFO - Processing values: 2018-01-28 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:07,508 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 9 hr time horizon... +2026-04-29 10:10:07,529 - __main__ - INFO - Processing values: 2018-01-08 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:08,462 - __main__ - INFO - Finished processing 2018-01-29 01:00:00 4 hr time horizon... +2026-04-29 10:10:08,482 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:08,750 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 11 hr time horizon... +2026-04-29 10:10:08,771 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:10,298 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 12 hr time horizon... +2026-04-29 10:10:10,325 - __main__ - INFO - Processing values: 2018-01-14 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:10,694 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 18 hr time horizon... +2026-04-29 10:10:10,714 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:10,968 - __main__ - INFO - Finished processing 2018-01-22 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:10,990 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:11,152 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:11,179 - __main__ - INFO - Processing values: 2018-01-23 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:11,599 - __main__ - INFO - Finished processing 2018-01-04 22:00:00 13 hr time horizon... +2026-04-29 10:10:11,627 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:12,886 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 4 hr time horizon... +2026-04-29 10:10:12,905 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:13,080 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 2 hr time horizon... +2026-04-29 10:10:13,102 - __main__ - INFO - Processing values: 2018-01-30 11:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:13,894 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 5 hr time horizon... +2026-04-29 10:10:13,918 - __main__ - INFO - Processing values: 2018-01-30 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:15,948 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 15 hr time horizon... +2026-04-29 10:10:15,971 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:16,689 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 13 hr time horizon... +2026-04-29 10:10:16,720 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:17,303 - __main__ - INFO - Finished processing 2018-01-26 20:00:00 14 hr time horizon... +2026-04-29 10:10:17,324 - __main__ - INFO - Processing values: 2018-01-14 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:18,706 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 7 hr time horizon... +2026-04-29 10:10:18,729 - __main__ - INFO - Processing values: 2018-01-03 21:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:18,970 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 1 hr time horizon... +2026-04-29 10:10:18,993 - __main__ - INFO - Processing values: 2018-01-04 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:19,614 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 11 hr time horizon... +2026-04-29 10:10:19,636 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:20,250 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:20,271 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:21,923 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 12 hr time horizon... +2026-04-29 10:10:21,943 - __main__ - INFO - Processing values: 2018-01-15 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:22,110 - __main__ - INFO - Finished processing 2018-01-08 23:00:00 2 hr time horizon... +2026-04-29 10:10:22,130 - __main__ - INFO - Processing values: 2018-01-18 18:00:00 9 hr time horizon... +2026-04-29 10:10:22,179 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 7 hr time horizon... +2026-04-29 10:10:22,199 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:24,369 - __main__ - INFO - Finished processing 2018-01-28 20:00:00 14 hr time horizon... +2026-04-29 10:10:24,394 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 7 hr time horizon... +2026-04-29 10:10:24,430 - __main__ - INFO - Finished processing 2018-01-14 01:00:00 7 hr time horizon... +2026-04-29 10:10:24,448 - __main__ - INFO - Processing values: 2018-01-04 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:24,579 - __main__ - INFO - Finished processing 2018-01-23 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:24,601 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:25,000 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 5 hr time horizon... +2026-04-29 10:10:25,029 - __main__ - INFO - Processing values: 2018-01-01 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:25,631 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 9 hr time horizon... +2026-04-29 10:10:25,656 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:26,375 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 10 hr time horizon... +2026-04-29 10:10:26,399 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:26,981 - __main__ - INFO - Finished processing 2018-01-30 11:00:00 2 hr time horizon... +2026-04-29 10:10:27,007 - __main__ - INFO - Processing values: 2018-01-23 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:27,717 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:27,743 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:30,070 - __main__ - INFO - Finished processing 2018-01-30 06:00:00 18 hr time horizon... +2026-04-29 10:10:30,092 - __main__ - INFO - Processing values: 2018-01-15 01:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:30,791 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 15 hr time horizon... +2026-04-29 10:10:30,812 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:30,981 - __main__ - INFO - Finished processing 2018-01-14 10:00:00 18 hr time horizon... +2026-04-29 10:10:31,006 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:31,574 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 2 hr time horizon... +2026-04-29 10:10:31,596 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:34,053 - __main__ - INFO - Finished processing 2018-01-03 21:00:00 13 hr time horizon... +2026-04-29 10:10:34,080 - __main__ - INFO - Processing values: 2018-01-02 18:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:34,093 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 2 hr time horizon... +2026-04-29 10:10:34,115 - __main__ - INFO - Processing values: 2018-01-29 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:34,653 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 17 hr time horizon... +2026-04-29 10:10:34,675 - __main__ - INFO - Processing values: 2018-01-11 07:00:00 2 hr time horizon... +2026-04-29 10:10:34,697 - __main__ - INFO - Finished processing 2018-01-04 07:00:00 13 hr time horizon... +2026-04-29 10:10:34,718 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:36,876 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 3 hr time horizon... +2026-04-29 10:10:36,898 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:37,286 - __main__ - INFO - Finished processing 2018-01-18 18:00:00 9 hr time horizon... +2026-04-29 10:10:37,308 - __main__ - INFO - Processing values: 2018-01-18 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:37,545 - __main__ - INFO - Finished processing 2018-01-15 20:00:00 2 hr time horizon... +2026-04-29 10:10:37,568 - __main__ - INFO - Processing values: 2018-01-28 11:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:39,060 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 7 hr time horizon... +2026-04-29 10:10:39,080 - __main__ - INFO - Processing values: 2018-01-12 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:39,113 - __main__ - INFO - Finished processing 2018-01-04 23:00:00 16 hr time horizon... +2026-04-29 10:10:39,136 - __main__ - INFO - Processing values: 2018-01-12 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:40,543 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 8 hr time horizon... +2026-04-29 10:10:40,568 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:40,878 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 8 hr time horizon... +2026-04-29 10:10:40,902 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:41,064 - __main__ - INFO - Finished processing 2018-01-01 19:00:00 16 hr time horizon... +2026-04-29 10:10:41,086 - __main__ - INFO - Processing values: 2018-01-27 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:41,680 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 13 hr time horizon... +2026-04-29 10:10:41,702 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:42,634 - __main__ - INFO - Finished processing 2018-01-23 22:00:00 11 hr time horizon... +2026-04-29 10:10:42,655 - __main__ - INFO - Processing values: 2018-01-25 08:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:43,465 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:43,487 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:44,790 - __main__ - INFO - Finished processing 2018-01-15 01:00:00 8 hr time horizon... +2026-04-29 10:10:44,809 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:46,048 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 11 hr time horizon... +2026-04-29 10:10:46,067 - __main__ - INFO - Processing values: 2018-01-20 15:00:00 4 hr time horizon... +2026-04-29 10:10:46,089 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 18 hr time horizon... +2026-04-29 10:10:46,115 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:48,106 - __main__ - INFO - Finished processing 2018-01-02 18:00:00 8 hr time horizon... +2026-04-29 10:10:48,127 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:49,348 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:49,377 - __main__ - INFO - Processing values: 2018-01-10 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:49,686 - __main__ - INFO - Finished processing 2018-01-29 06:00:00 15 hr time horizon... +2026-04-29 10:10:49,725 - __main__ - INFO - Processing values: 2018-01-16 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:50,782 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:50,806 - __main__ - INFO - Processing values: 2018-01-11 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:51,246 - __main__ - INFO - Finished processing 2018-01-11 07:00:00 2 hr time horizon... +2026-04-29 10:10:51,269 - __main__ - INFO - Processing values: 2018-01-29 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:51,741 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 18 hr time horizon... +2026-04-29 10:10:51,766 - __main__ - INFO - Processing values: 2018-01-08 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:51,811 - __main__ - INFO - Finished processing 2018-01-18 09:00:00 3 hr time horizon... +2026-04-29 10:10:51,836 - __main__ - INFO - Processing values: 2018-01-22 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:53,638 - __main__ - INFO - Finished processing 2018-01-12 11:00:00 16 hr time horizon... +2026-04-29 10:10:53,659 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:54,104 - __main__ - INFO - Finished processing 2018-01-12 18:00:00 6 hr time horizon... +2026-04-29 10:10:54,139 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:54,909 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 4 hr time horizon... +2026-04-29 10:10:54,931 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:55,941 - __main__ - INFO - Finished processing 2018-01-27 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:55,964 - __main__ - INFO - Processing values: 2018-01-19 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:56,962 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 14 hr time horizon... +2026-04-29 10:10:56,987 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:57,389 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 11 hr time horizon... +2026-04-29 10:10:57,413 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 15 hr time horizon... +2026-04-29 10:10:57,497 - __main__ - INFO - Finished processing 2018-01-25 08:00:00 2 hr time horizon... +2026-04-29 10:10:57,518 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:58,222 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:10:58,244 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:00,557 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 10 hr time horizon... +2026-04-29 10:11:00,579 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:01,237 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 6 hr time horizon... +2026-04-29 10:11:01,260 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:01,394 - __main__ - INFO - Finished processing 2018-01-20 15:00:00 4 hr time horizon... +2026-04-29 10:11:01,415 - __main__ - INFO - Processing values: 2018-01-29 00:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:03,146 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 5 hr time horizon... +2026-04-29 10:11:03,168 - __main__ - INFO - Processing values: 2018-01-29 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:04,969 - __main__ - INFO - Finished processing 2018-01-16 07:00:00 10 hr time horizon... +2026-04-29 10:11:04,990 - __main__ - INFO - Processing values: 2018-01-09 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:05,231 - __main__ - INFO - Finished processing 2018-01-28 11:00:00 14 hr time horizon... +2026-04-29 10:11:05,260 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:06,197 - __main__ - INFO - Finished processing 2018-01-11 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:06,218 - __main__ - INFO - Processing values: 2018-01-03 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:06,311 - __main__ - INFO - Finished processing 2018-01-29 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:06,335 - __main__ - INFO - Processing values: 2018-01-22 08:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:07,307 - __main__ - INFO - Finished processing 2018-01-22 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:07,330 - __main__ - INFO - Processing values: 2018-01-05 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:08,620 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 9 hr time horizon... +2026-04-29 10:11:08,642 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:08,822 - __main__ - INFO - Finished processing 2018-01-08 16:00:00 6 hr time horizon... +2026-04-29 10:11:08,849 - __main__ - INFO - Processing values: 2018-01-17 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:09,063 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 2 hr time horizon... +2026-04-29 10:11:09,085 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:09,258 - __main__ - INFO - Finished processing 2018-01-10 13:00:00 8 hr time horizon... +2026-04-29 10:11:09,287 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:10,371 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:10,395 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:11,480 - __main__ - INFO - Finished processing 2018-01-19 20:00:00 10 hr time horizon... +2026-04-29 10:11:11,502 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:11,745 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 5 hr time horizon... +2026-04-29 10:11:11,765 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:12,641 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 15 hr time horizon... +2026-04-29 10:11:12,665 - __main__ - INFO - Processing values: 2018-01-07 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:12,913 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 4 hr time horizon... +2026-04-29 10:11:12,934 - __main__ - INFO - Processing values: 2018-01-16 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:15,812 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 6 hr time horizon... +2026-04-29 10:11:15,835 - __main__ - INFO - Processing values: 2018-01-14 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:15,978 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 17 hr time horizon... +2026-04-29 10:11:16,007 - __main__ - INFO - Processing values: 2018-01-04 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:16,373 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 5 hr time horizon... +2026-04-29 10:11:16,396 - __main__ - INFO - Processing values: 2018-01-29 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:17,327 - __main__ - INFO - Finished processing 2018-01-29 00:00:00 16 hr time horizon... +2026-04-29 10:11:17,363 - __main__ - INFO - Processing values: 2018-01-30 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:18,104 - __main__ - INFO - Finished processing 2018-01-29 21:00:00 2 hr time horizon... +2026-04-29 10:11:18,124 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:20,631 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 10 hr time horizon... +2026-04-29 10:11:20,654 - __main__ - INFO - Processing values: 2018-01-02 09:00:00 10 hr time horizon... +2026-04-29 10:11:20,756 - __main__ - INFO - Finished processing 2018-01-09 13:00:00 17 hr time horizon... +2026-04-29 10:11:20,782 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:21,679 - __main__ - INFO - Finished processing 2018-01-03 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:21,701 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:21,924 - __main__ - INFO - Finished processing 2018-01-22 08:00:00 6 hr time horizon... +2026-04-29 10:11:21,950 - __main__ - INFO - Processing values: 2018-01-24 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:22,851 - __main__ - INFO - Finished processing 2018-01-05 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:22,879 - __main__ - INFO - Processing values: 2018-01-16 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:23,932 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 8 hr time horizon... +2026-04-29 10:11:23,959 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:24,540 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 13 hr time horizon... +2026-04-29 10:11:24,572 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:24,841 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 9 hr time horizon... +2026-04-29 10:11:24,864 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:24,928 - __main__ - INFO - Finished processing 2018-01-17 19:00:00 17 hr time horizon... +2026-04-29 10:11:24,951 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:25,906 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 11 hr time horizon... +2026-04-29 10:11:25,929 - __main__ - INFO - Processing values: 2018-01-01 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:26,776 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 5 hr time horizon... +2026-04-29 10:11:26,800 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:27,195 - __main__ - INFO - Finished processing 2018-01-07 08:00:00 4 hr time horizon... +2026-04-29 10:11:27,221 - __main__ - INFO - Processing values: 2018-01-03 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:27,676 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:27,697 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:29,058 - __main__ - INFO - Finished processing 2018-01-16 16:00:00 12 hr time horizon... +2026-04-29 10:11:29,085 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:31,679 - __main__ - INFO - Finished processing 2018-01-14 15:00:00 8 hr time horizon... +2026-04-29 10:11:31,700 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 2 hr time horizon... +2026-04-29 10:11:31,756 - __main__ - INFO - Finished processing 2018-01-04 03:00:00 13 hr time horizon... +2026-04-29 10:11:31,780 - __main__ - INFO - Processing values: 2018-01-28 04:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:31,866 - __main__ - INFO - Finished processing 2018-01-29 09:00:00 10 hr time horizon... +2026-04-29 10:11:31,892 - __main__ - INFO - Processing values: 2018-01-24 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:32,558 - __main__ - INFO - Finished processing 2018-01-30 12:00:00 3 hr time horizon... +2026-04-29 10:11:32,579 - __main__ - INFO - Processing values: 2018-01-27 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:33,591 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 14 hr time horizon... +2026-04-29 10:11:33,613 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:36,150 - __main__ - INFO - Finished processing 2018-01-02 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:36,174 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:37,059 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:37,084 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:37,488 - __main__ - INFO - Finished processing 2018-01-24 02:00:00 14 hr time horizon... +2026-04-29 10:11:37,515 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:37,719 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 12 hr time horizon... +2026-04-29 10:11:37,741 - __main__ - INFO - Processing values: 2018-01-20 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:38,345 - __main__ - INFO - Finished processing 2018-01-16 08:00:00 18 hr time horizon... +2026-04-29 10:11:38,366 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:39,870 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 4 hr time horizon... +2026-04-29 10:11:39,891 - __main__ - INFO - Processing values: 2018-01-20 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:39,906 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 4 hr time horizon... +2026-04-29 10:11:39,928 - __main__ - INFO - Processing values: 2018-01-25 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:40,337 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 6 hr time horizon... +2026-04-29 10:11:40,359 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:40,819 - __main__ - INFO - Finished processing 2018-01-01 08:00:00 8 hr time horizon... +2026-04-29 10:11:40,843 - __main__ - INFO - Processing values: 2018-01-08 05:00:00 14 hr time horizon... +2026-04-29 10:11:40,877 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 11 hr time horizon... +2026-04-29 10:11:40,900 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:43,608 - __main__ - INFO - Finished processing 2018-01-03 12:00:00 7 hr time horizon... +2026-04-29 10:11:43,637 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:44,072 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 18 hr time horizon... +2026-04-29 10:11:44,099 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 14 hr time horizon... +2026-04-29 10:11:44,207 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 11 hr time horizon... +2026-04-29 10:11:44,233 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:44,359 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 17 hr time horizon... +2026-04-29 10:11:44,391 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:46,585 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 2 hr time horizon... +2026-04-29 10:11:46,610 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:47,283 - __main__ - INFO - Finished processing 2018-01-24 08:00:00 9 hr time horizon... +2026-04-29 10:11:47,307 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:48,014 - __main__ - INFO - Finished processing 2018-01-28 04:00:00 3 hr time horizon... +2026-04-29 10:11:48,035 - __main__ - INFO - Processing values: 2018-01-17 20:00:00 4 hr time horizon... +2026-04-29 10:11:48,267 - __main__ - INFO - Finished processing 2018-01-27 09:00:00 17 hr time horizon... +2026-04-29 10:11:48,289 - __main__ - INFO - Processing values: 2018-01-28 22:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:11:52,144 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:52,173 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:52,973 - __main__ - INFO - Finished processing 2018-01-20 13:00:00 17 hr time horizon... +2026-04-29 10:11:52,996 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:53,205 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:53,236 - __main__ - INFO - Processing values: 2018-01-13 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:53,906 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 14 hr time horizon... +2026-04-29 10:11:53,925 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 9 hr time horizon... +2026-04-29 10:11:53,935 - __main__ - INFO - Processing values: 2018-01-22 21:00:00 5 hr time horizon... +2026-04-29 10:11:53,947 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:54,120 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:54,148 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:55,421 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 8 hr time horizon... +2026-04-29 10:11:55,440 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:55,650 - __main__ - INFO - Finished processing 2018-01-20 01:00:00 12 hr time horizon... +2026-04-29 10:11:55,676 - __main__ - INFO - Processing values: 2018-01-15 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:56,391 - __main__ - INFO - Finished processing 2018-01-08 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:56,429 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:56,759 - __main__ - INFO - Finished processing 2018-01-25 02:00:00 11 hr time horizon... +2026-04-29 10:11:56,782 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:57,017 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 15 hr time horizon... +2026-04-29 10:11:57,041 - __main__ - INFO - Processing values: 2018-01-23 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:58,967 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 14 hr time horizon... +2026-04-29 10:11:58,989 - __main__ - INFO - Processing values: 2018-01-06 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:11:59,327 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 10 hr time horizon... +2026-04-29 10:11:59,352 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 4 hr time horizon... +2026-04-29 10:11:59,500 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 1 hr time horizon... +2026-04-29 10:11:59,522 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:01,112 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:01,138 - __main__ - INFO - Processing values: 2018-01-28 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:02,781 - __main__ - INFO - Finished processing 2018-01-28 22:00:00 18 hr time horizon... +2026-04-29 10:12:02,803 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:02,997 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 17 hr time horizon... +2026-04-29 10:12:03,021 - __main__ - INFO - Processing values: 2018-01-21 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:03,691 - __main__ - INFO - Finished processing 2018-01-17 20:00:00 4 hr time horizon... +2026-04-29 10:12:03,714 - __main__ - INFO - Processing values: 2018-01-29 08:00:00 13 hr time horizon... +2026-04-29 10:12:03,806 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 16 hr time horizon... +2026-04-29 10:12:03,829 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:07,053 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 15 hr time horizon... +2026-04-29 10:12:07,080 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:08,039 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 10 hr time horizon... +2026-04-29 10:12:08,063 - __main__ - INFO - Processing values: 2018-01-29 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:08,295 - __main__ - INFO - Finished processing 2018-01-22 21:00:00 5 hr time horizon... +2026-04-29 10:12:08,319 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:09,337 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:09,366 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:09,938 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 3 hr time horizon... +2026-04-29 10:12:09,961 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:10,491 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:10,514 - __main__ - INFO - Processing values: 2018-01-22 19:00:00 6 hr time horizon... +2026-04-29 10:12:10,544 - __main__ - INFO - Finished processing 2018-01-15 05:00:00 11 hr time horizon... +2026-04-29 10:12:10,566 - __main__ - INFO - Processing values: 2018-01-07 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:12,008 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 7 hr time horizon... +2026-04-29 10:12:12,036 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:12,479 - __main__ - INFO - Finished processing 2018-01-23 03:00:00 8 hr time horizon... +2026-04-29 10:12:12,516 - __main__ - INFO - Processing values: 2018-01-17 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:13,080 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 16 hr time horizon... +2026-04-29 10:12:13,102 - __main__ - INFO - Processing values: 2018-01-09 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:14,847 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 4 hr time horizon... +2026-04-29 10:12:14,871 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:15,173 - __main__ - INFO - Finished processing 2018-01-06 16:00:00 3 hr time horizon... +2026-04-29 10:12:15,198 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:15,764 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 18 hr time horizon... +2026-04-29 10:12:15,786 - __main__ - INFO - Processing values: 2018-01-22 11:00:00 1 hr time horizon... +2026-04-29 10:12:16,094 - __main__ - INFO - Finished processing 2018-01-28 19:00:00 9 hr time horizon... +2026-04-29 10:12:16,117 - __main__ - INFO - Processing values: 2018-01-23 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:19,261 - __main__ - INFO - Finished processing 2018-01-29 08:00:00 13 hr time horizon... +2026-04-29 10:12:19,294 - __main__ - INFO - Processing values: 2018-01-21 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:19,629 - __main__ - INFO - Finished processing 2018-01-21 15:00:00 14 hr time horizon... +2026-04-29 10:12:19,654 - __main__ - INFO - Processing values: 2018-01-14 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:19,885 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:19,908 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 9 hr time horizon... +2026-04-29 10:12:19,928 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 2 hr time horizon... +2026-04-29 10:12:19,951 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:21,530 - __main__ - INFO - Finished processing 2018-01-13 22:00:00 5 hr time horizon... +2026-04-29 10:12:21,546 - __main__ - INFO - Processing values: 2018-01-18 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:21,693 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 10 hr time horizon... +2026-04-29 10:12:21,717 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:24,338 - __main__ - INFO - Finished processing 2018-01-29 05:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:24,373 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:24,986 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:25,009 - __main__ - INFO - Processing values: 2018-01-09 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:25,087 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:25,105 - __main__ - INFO - Processing values: 2018-01-23 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:26,083 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 8 hr time horizon... +2026-04-29 10:12:26,109 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 10 hr time horizon... +2026-04-29 10:12:26,155 - __main__ - INFO - Finished processing 2018-01-22 19:00:00 6 hr time horizon... +2026-04-29 10:12:26,178 - __main__ - INFO - Processing values: 2018-01-29 23:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:26,477 - __main__ - INFO - Finished processing 2018-01-07 20:00:00 14 hr time horizon... +2026-04-29 10:12:26,504 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:27,448 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 11 hr time horizon... +2026-04-29 10:12:27,469 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 13 hr time horizon... +2026-04-29 10:12:27,560 - __main__ - INFO - Finished processing 2018-01-17 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:27,583 - __main__ - INFO - Processing values: 2018-01-11 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:27,855 - __main__ - INFO - Finished processing 2018-01-09 19:00:00 16 hr time horizon... +2026-04-29 10:12:27,891 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:29,810 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 16 hr time horizon... +2026-04-29 10:12:29,830 - __main__ - INFO - Processing values: 2018-01-13 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:30,308 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 11 hr time horizon... +2026-04-29 10:12:30,329 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:31,258 - __main__ - INFO - Finished processing 2018-01-23 19:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:31,278 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 17 hr time horizon... +2026-04-29 10:12:31,377 - __main__ - INFO - Finished processing 2018-01-22 11:00:00 1 hr time horizon... +2026-04-29 10:12:31,398 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:34,158 - __main__ - INFO - Finished processing 2018-01-21 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:34,182 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:34,319 - __main__ - INFO - Finished processing 2018-01-14 04:00:00 7 hr time horizon... +2026-04-29 10:12:34,342 - __main__ - INFO - Processing values: 2018-01-13 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:35,134 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 9 hr time horizon... +2026-04-29 10:12:35,158 - __main__ - INFO - Processing values: 2018-01-01 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:35,572 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 5 hr time horizon... +2026-04-29 10:12:35,592 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 17 hr time horizon... +2026-04-29 10:12:36,022 - __main__ - INFO - Finished processing 2018-01-18 10:00:00 9 hr time horizon... +2026-04-29 10:12:36,041 - __main__ - INFO - Processing values: 2018-01-18 08:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:39,233 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 7 hr time horizon... +2026-04-29 10:12:39,264 - __main__ - INFO - Processing values: 2018-01-29 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:40,415 - __main__ - INFO - Finished processing 2018-01-09 01:00:00 7 hr time horizon... +2026-04-29 10:12:40,440 - __main__ - INFO - Processing values: 2018-01-15 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:41,044 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 5 hr time horizon... +2026-04-29 10:12:41,064 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:41,314 - __main__ - INFO - Finished processing 2018-01-23 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:41,350 - __main__ - INFO - Processing values: 2018-01-12 00:00:00 11 hr time horizon... +2026-04-29 10:12:41,365 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 10 hr time horizon... +2026-04-29 10:12:41,391 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:41,962 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:41,986 - __main__ - INFO - Processing values: 2018-01-01 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:43,030 - __main__ - INFO - Finished processing 2018-01-11 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:43,056 - __main__ - INFO - Processing values: 2018-01-11 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:43,667 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:43,691 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:44,357 - __main__ - INFO - Finished processing 2018-01-13 11:00:00 3 hr time horizon... +2026-04-29 10:12:44,381 - __main__ - INFO - Processing values: 2018-01-01 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:45,519 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 12 hr time horizon... +2026-04-29 10:12:45,538 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:45,689 - __main__ - INFO - Finished processing 2018-01-29 23:00:00 4 hr time horizon... +2026-04-29 10:12:45,709 - __main__ - INFO - Processing values: 2018-01-20 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:46,714 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 17 hr time horizon... +2026-04-29 10:12:46,737 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:47,608 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 9 hr time horizon... +2026-04-29 10:12:47,632 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:47,808 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 11 hr time horizon... +2026-04-29 10:12:47,829 - __main__ - INFO - Processing values: 2018-01-08 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:49,087 - __main__ - INFO - Finished processing 2018-01-13 20:00:00 2 hr time horizon... +2026-04-29 10:12:49,106 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 7 hr time horizon... +2026-04-29 10:12:49,121 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 2 hr time horizon... +2026-04-29 10:12:49,145 - __main__ - INFO - Processing values: 2018-01-28 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:49,691 - __main__ - INFO - Finished processing 2018-01-01 15:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:49,715 - __main__ - INFO - Processing values: 2018-01-16 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:51,495 - __main__ - INFO - Finished processing 2018-01-18 08:00:00 18 hr time horizon... +2026-04-29 10:12:51,516 - __main__ - INFO - Processing values: 2018-01-15 15:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:52,828 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 17 hr time horizon... +2026-04-29 10:12:52,854 - __main__ - INFO - Processing values: 2018-01-23 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:54,178 - __main__ - INFO - Finished processing 2018-01-29 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:54,200 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:56,150 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 10 hr time horizon... +2026-04-29 10:12:56,180 - __main__ - INFO - Processing values: 2018-01-19 14:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:56,313 - __main__ - INFO - Finished processing 2018-01-01 00:00:00 1 hr time horizon... +2026-04-29 10:12:56,330 - __main__ - INFO - Processing values: 2018-01-21 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:56,618 - __main__ - INFO - Finished processing 2018-01-15 14:00:00 13 hr time horizon... +2026-04-29 10:12:56,641 - __main__ - INFO - Processing values: 2018-01-12 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:56,829 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 3 hr time horizon... +2026-04-29 10:12:56,869 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:57,249 - __main__ - INFO - Finished processing 2018-01-12 00:00:00 11 hr time horizon... +2026-04-29 10:12:57,271 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:58,106 - __main__ - INFO - Finished processing 2018-01-11 22:00:00 2 hr time horizon... +2026-04-29 10:12:58,137 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:12:58,353 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 1 hr time horizon... +2026-04-29 10:12:58,376 - __main__ - INFO - Processing values: 2018-01-04 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:00,049 - __main__ - INFO - Finished processing 2018-01-01 07:00:00 12 hr time horizon... +2026-04-29 10:13:00,069 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:00,730 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 10 hr time horizon... +2026-04-29 10:13:00,754 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:01,213 - __main__ - INFO - Finished processing 2018-01-20 20:00:00 6 hr time horizon... +2026-04-29 10:13:01,239 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:01,905 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 4 hr time horizon... +2026-04-29 10:13:01,928 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:03,580 - __main__ - INFO - Finished processing 2018-01-01 23:00:00 14 hr time horizon... +2026-04-29 10:13:03,603 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:04,505 - __main__ - INFO - Finished processing 2018-01-08 04:00:00 7 hr time horizon... +2026-04-29 10:13:04,529 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:04,688 - __main__ - INFO - Finished processing 2018-01-28 17:00:00 2 hr time horizon... +2026-04-29 10:13:04,710 - __main__ - INFO - Processing values: 2018-01-03 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:04,830 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 7 hr time horizon... +2026-04-29 10:13:04,854 - __main__ - INFO - Processing values: 2018-01-16 23:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:05,364 - __main__ - INFO - Finished processing 2018-01-16 12:00:00 4 hr time horizon... +2026-04-29 10:13:05,385 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:07,204 - __main__ - INFO - Finished processing 2018-01-15 15:00:00 11 hr time horizon... +2026-04-29 10:13:07,224 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:08,257 - __main__ - INFO - Finished processing 2018-01-23 16:00:00 7 hr time horizon... +2026-04-29 10:13:08,278 - __main__ - INFO - Processing values: 2018-01-08 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:09,893 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 13 hr time horizon... +2026-04-29 10:13:09,916 - __main__ - INFO - Processing values: 2018-01-10 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:11,545 - __main__ - INFO - Finished processing 2018-01-21 14:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:11,567 - __main__ - INFO - Processing values: 2018-01-15 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:12,672 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 14 hr time horizon... +2026-04-29 10:13:12,693 - __main__ - INFO - Processing values: 2018-01-05 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:13,000 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:13,024 - __main__ - INFO - Processing values: 2018-01-18 19:00:00 12 hr time horizon... +2026-04-29 10:13:13,041 - __main__ - INFO - Finished processing 2018-01-19 14:00:00 15 hr time horizon... +2026-04-29 10:13:13,063 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 4 hr time horizon... +2026-04-29 10:13:13,072 - __main__ - INFO - Finished processing 2018-01-04 01:00:00 5 hr time horizon... +2026-04-29 10:13:13,089 - __main__ - INFO - Processing values: 2018-01-01 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:13,633 - __main__ - INFO - Finished processing 2018-01-12 14:00:00 16 hr time horizon... +2026-04-29 10:13:13,650 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 13 hr time horizon... +2026-04-29 10:13:13,655 - __main__ - INFO - Processing values: 2018-01-10 00:00:00 15 hr time horizon... +2026-04-29 10:13:13,670 - __main__ - INFO - Processing values: 2018-01-19 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:16,179 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 8 hr time horizon... +2026-04-29 10:13:16,203 - __main__ - INFO - Processing values: 2018-01-04 04:00:00 18 hr time horizon... +2026-04-29 10:13:16,329 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 2 hr time horizon... +2026-04-29 10:13:16,351 - __main__ - INFO - Processing values: 2018-01-12 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:16,462 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 8 hr time horizon... +2026-04-29 10:13:16,483 - __main__ - INFO - Processing values: 2018-01-01 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:17,439 - __main__ - INFO - Finished processing 2018-01-06 05:00:00 1 hr time horizon... +2026-04-29 10:13:17,458 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:19,462 - __main__ - INFO - Finished processing 2018-01-16 23:00:00 1 hr time horizon... +2026-04-29 10:13:19,480 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:20,028 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 16 hr time horizon... +2026-04-29 10:13:20,051 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:21,219 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 13 hr time horizon... +2026-04-29 10:13:21,244 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:21,764 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 9 hr time horizon... +2026-04-29 10:13:21,788 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:22,381 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 11 hr time horizon... +2026-04-29 10:13:22,403 - __main__ - INFO - Processing values: 2018-01-02 17:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:23,138 - __main__ - INFO - Finished processing 2018-01-03 17:00:00 12 hr time horizon... +2026-04-29 10:13:23,163 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:24,130 - __main__ - INFO - Finished processing 2018-01-08 03:00:00 2 hr time horizon... +2026-04-29 10:13:24,153 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:26,091 - __main__ - INFO - Finished processing 2018-01-10 04:00:00 16 hr time horizon... +2026-04-29 10:13:26,131 - __main__ - INFO - Processing values: 2018-01-02 00:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:26,679 - __main__ - INFO - Finished processing 2018-01-15 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:26,699 - __main__ - INFO - Processing values: 2018-01-15 23:00:00 10 hr time horizon... +2026-04-29 10:13:26,768 - __main__ - INFO - Finished processing 2018-01-01 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:26,794 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:27,479 - __main__ - INFO - Finished processing 2018-01-05 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:27,499 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:28,572 - __main__ - INFO - Finished processing 2018-01-18 19:00:00 12 hr time horizon... +2026-04-29 10:13:28,593 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 10 hr time horizon... +2026-04-29 10:13:28,601 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 4 hr time horizon... +2026-04-29 10:13:28,623 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:13:28,842 - __main__ - INFO - Finished processing 2018-01-19 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:28,870 - __main__ - INFO - Processing values: 2018-01-08 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:29,465 - __main__ - INFO - Finished processing 2018-01-10 00:00:00 15 hr time horizon... +2026-04-29 10:13:29,492 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:31,136 - __main__ - INFO - Finished processing 2018-01-01 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:31,144 - __main__ - INFO - Finished processing 2018-01-04 04:00:00 18 hr time horizon... +2026-04-29 10:13:31,162 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 5 hr time horizon... +2026-04-29 10:13:31,170 - __main__ - INFO - Processing values: 2018-01-03 07:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:31,565 - __main__ - INFO - Finished processing 2018-01-12 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:31,587 - __main__ - INFO - Processing values: 2018-01-14 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:32,407 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 7 hr time horizon... +2026-04-29 10:13:32,428 - __main__ - INFO - Processing values: 2018-01-29 12:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:33,525 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 6 hr time horizon... +2026-04-29 10:13:33,545 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:34,034 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 1 hr time horizon... +2026-04-29 10:13:34,053 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:35,407 - __main__ - INFO - Finished processing 2018-01-10 08:00:00 17 hr time horizon... +2026-04-29 10:13:35,430 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:13:55,940 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 11 hr time horizon... +2026-04-29 10:13:55,956 - __main__ - INFO - Processing values: 2018-01-28 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:04,681 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 10 hr time horizon... +2026-04-29 10:14:04,698 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 6 hr time horizon... +2026-04-29 10:14:04,701 - __main__ - INFO - Finished processing 2018-01-03 07:00:00 16 hr time horizon... +2026-04-29 10:14:04,721 - __main__ - INFO - Processing values: 2018-01-14 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:06,132 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 11 hr time horizon... +2026-04-29 10:14:06,149 - __main__ - INFO - Processing values: 2018-01-04 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:07,157 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 11 hr time horizon... +2026-04-29 10:14:07,177 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:12,650 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:12,672 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:13,292 - __main__ - INFO - Finished processing 2018-01-02 17:00:00 7 hr time horizon... +2026-04-29 10:14:13,312 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:15,218 - __main__ - INFO - Finished processing 2018-01-02 00:00:00 13 hr time horizon... +2026-04-29 10:14:15,238 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:15,430 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 12 hr time horizon... +2026-04-29 10:14:15,451 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 6 hr time horizon... +2026-04-29 10:14:15,473 - __main__ - INFO - Finished processing 2018-01-28 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:15,496 - __main__ - INFO - Processing values: 2018-01-20 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:16,692 - __main__ - INFO - Finished processing 2018-01-08 15:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:16,722 - __main__ - INFO - Processing values: 2018-01-13 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:17,167 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 8 hr time horizon... +2026-04-29 10:14:17,200 - __main__ - INFO - Processing values: 2018-01-10 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:17,708 - __main__ - INFO - Finished processing 2018-01-14 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:17,732 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:18,234 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 6 hr time horizon... +2026-04-29 10:14:18,260 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:18,772 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 2 hr time horizon... +2026-04-29 10:14:18,782 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 7 hr time horizon... +2026-04-29 10:14:18,794 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 14 hr time horizon... +2026-04-29 10:14:18,809 - __main__ - INFO - Processing values: 2018-01-25 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:19,062 - __main__ - INFO - Finished processing 2018-01-15 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:19,084 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:19,566 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 10 hr time horizon... +2026-04-29 10:14:19,591 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:20,114 - __main__ - INFO - Finished processing 2018-01-04 17:00:00 18 hr time horizon... +2026-04-29 10:14:20,142 - __main__ - INFO - Processing values: 2018-01-09 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:20,785 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 9 hr time horizon... +2026-04-29 10:14:20,811 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 4 hr time horizon... +2026-04-29 10:14:21,347 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 13 hr time horizon... +2026-04-29 10:14:21,374 - __main__ - INFO - Processing values: 2018-01-10 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:25,735 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 9 hr time horizon... +2026-04-29 10:14:25,763 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:25,963 - __main__ - INFO - Finished processing 2018-01-29 12:00:00 3 hr time horizon... +2026-04-29 10:14:25,994 - __main__ - INFO - Processing values: 2018-01-06 12:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:27,076 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 14 hr time horizon... +2026-04-29 10:14:27,102 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:27,299 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:27,322 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:29,105 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 7 hr time horizon... +2026-04-29 10:14:29,127 - __main__ - INFO - Processing values: 2018-01-08 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:30,232 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:30,262 - __main__ - INFO - Processing values: 2018-01-30 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:31,188 - __main__ - INFO - Finished processing 2018-01-13 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:31,212 - __main__ - INFO - Processing values: 2018-01-26 13:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:31,619 - __main__ - INFO - Finished processing 2018-01-10 23:00:00 9 hr time horizon... +2026-04-29 10:14:31,645 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:32,133 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 13 hr time horizon... +2026-04-29 10:14:32,163 - __main__ - INFO - Processing values: 2018-01-28 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:32,655 - __main__ - INFO - Finished processing 2018-01-20 21:00:00 17 hr time horizon... +2026-04-29 10:14:32,689 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:33,269 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 14 hr time horizon... +2026-04-29 10:14:33,297 - __main__ - INFO - Processing values: 2018-01-03 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:33,745 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 9 hr time horizon... +2026-04-29 10:14:33,767 - __main__ - INFO - Processing values: 2018-01-23 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:34,332 - __main__ - INFO - Finished processing 2018-01-25 12:00:00 16 hr time horizon... +2026-04-29 10:14:34,355 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:35,144 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 8 hr time horizon... +2026-04-29 10:14:35,167 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 9 hr time horizon... +2026-04-29 10:14:35,318 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 4 hr time horizon... +2026-04-29 10:14:35,342 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:35,528 - __main__ - INFO - Finished processing 2018-01-09 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:35,552 - __main__ - INFO - Processing values: 2018-01-27 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:36,171 - __main__ - INFO - Finished processing 2018-01-10 06:00:00 18 hr time horizon... +2026-04-29 10:14:36,202 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:37,209 - __main__ - INFO - Finished processing 2018-01-14 19:00:00 16 hr time horizon... +2026-04-29 10:14:37,233 - __main__ - INFO - Processing values: 2018-01-01 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:38,109 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 16 hr time horizon... +2026-04-29 10:14:38,138 - __main__ - INFO - Processing values: 2018-01-05 04:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:40,205 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:40,239 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:41,261 - __main__ - INFO - Finished processing 2018-01-06 12:00:00 11 hr time horizon... +2026-04-29 10:14:41,285 - __main__ - INFO - Processing values: 2018-01-08 00:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:41,736 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 18 hr time horizon... +2026-04-29 10:14:41,755 - __main__ - INFO - Processing values: 2018-01-04 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:14:42,658 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:42,686 - __main__ - INFO - Processing values: 2018-01-29 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:44,590 - __main__ - INFO - Finished processing 2018-01-08 18:00:00 14 hr time horizon... +2026-04-29 10:14:44,615 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:45,309 - __main__ - INFO - Finished processing 2018-01-30 13:00:00 16 hr time horizon... +2026-04-29 10:14:45,333 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:46,546 - __main__ - INFO - Finished processing 2018-01-26 13:00:00 9 hr time horizon... +2026-04-29 10:14:46,568 - __main__ - INFO - Processing values: 2018-01-17 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:46,748 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 6 hr time horizon... +2026-04-29 10:14:46,767 - __main__ - INFO - Processing values: 2018-01-13 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:48,107 - __main__ - INFO - Finished processing 2018-01-28 06:00:00 4 hr time horizon... +2026-04-29 10:14:48,134 - __main__ - INFO - Processing values: 2018-01-17 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:48,506 - __main__ - INFO - Finished processing 2018-01-03 22:00:00 15 hr time horizon... +2026-04-29 10:14:48,527 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:49,244 - __main__ - INFO - Finished processing 2018-01-23 04:00:00 9 hr time horizon... +2026-04-29 10:14:49,270 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:49,984 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 9 hr time horizon... +2026-04-29 10:14:50,005 - __main__ - INFO - Processing values: 2018-01-05 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:50,153 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 17 hr time horizon... +2026-04-29 10:14:50,179 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:50,326 - __main__ - INFO - Finished processing 2018-01-27 10:00:00 1 hr time horizon... +2026-04-29 10:14:50,346 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:51,018 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 4 hr time horizon... +2026-04-29 10:14:51,041 - __main__ - INFO - Processing values: 2018-01-17 23:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:51,591 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 7 hr time horizon... +2026-04-29 10:14:51,613 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:53,767 - __main__ - INFO - Finished processing 2018-01-05 04:00:00 5 hr time horizon... +2026-04-29 10:14:53,786 - __main__ - INFO - Processing values: 2018-01-16 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:54,312 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 6 hr time horizon... +2026-04-29 10:14:54,334 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:56,193 - __main__ - INFO - Finished processing 2018-01-04 06:00:00 5 hr time horizon... +2026-04-29 10:14:56,215 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:57,206 - __main__ - INFO - Finished processing 2018-01-08 00:00:00 14 hr time horizon... +2026-04-29 10:14:57,230 - __main__ - INFO - Processing values: 2018-01-06 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:58,209 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 7 hr time horizon... +2026-04-29 10:14:58,230 - __main__ - INFO - Processing values: 2018-01-19 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:58,533 - __main__ - INFO - Finished processing 2018-01-01 06:00:00 18 hr time horizon... +2026-04-29 10:14:58,554 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:58,743 - __main__ - INFO - Finished processing 2018-01-29 13:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:58,765 - __main__ - INFO - Processing values: 2018-01-24 20:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:59,124 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 17 hr time horizon... +2026-04-29 10:14:59,145 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 2 hr time horizon... +2026-04-29 10:14:59,359 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:14:59,382 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:00,992 - __main__ - INFO - Finished processing 2018-01-13 15:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:01,030 - __main__ - INFO - Processing values: 2018-01-03 17:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:01,803 - __main__ - INFO - Finished processing 2018-01-17 14:00:00 2 hr time horizon... +2026-04-29 10:15:01,825 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:02,468 - __main__ - INFO - Finished processing 2018-01-17 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:02,495 - __main__ - INFO - Processing values: 2018-01-02 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:02,741 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 7 hr time horizon... +2026-04-29 10:15:02,766 - __main__ - INFO - Processing values: 2018-01-28 01:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:03,137 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 2 hr time horizon... +2026-04-29 10:15:03,157 - __main__ - INFO - Processing values: 2018-01-28 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:04,118 - __main__ - INFO - Finished processing 2018-01-05 21:00:00 15 hr time horizon... +2026-04-29 10:15:04,143 - __main__ - INFO - Processing values: 2018-01-11 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:04,631 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 3 hr time horizon... +2026-04-29 10:15:04,653 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 10 hr time horizon... +2026-04-29 10:15:04,676 - __main__ - INFO - Finished processing 2018-01-27 21:00:00 8 hr time horizon... +2026-04-29 10:15:04,701 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:05,937 - __main__ - INFO - Finished processing 2018-01-17 23:00:00 12 hr time horizon... +2026-04-29 10:15:05,963 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:07,806 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 5 hr time horizon... +2026-04-29 10:15:07,829 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:08,794 - __main__ - INFO - Finished processing 2018-01-16 09:00:00 7 hr time horizon... +2026-04-29 10:15:08,814 - __main__ - INFO - Processing values: 2018-01-23 09:00:00 13 hr time horizon... +2026-04-29 10:15:08,971 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 10 hr time horizon... +2026-04-29 10:15:08,993 - __main__ - INFO - Processing values: 2018-01-25 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:11,235 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 14 hr time horizon... +2026-04-29 10:15:11,260 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:12,182 - __main__ - INFO - Finished processing 2018-01-06 22:00:00 3 hr time horizon... +2026-04-29 10:15:12,200 - __main__ - INFO - Processing values: 2018-01-19 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:12,614 - __main__ - INFO - Finished processing 2018-01-19 16:00:00 3 hr time horizon... +2026-04-29 10:15:12,635 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:13,077 - __main__ - INFO - Finished processing 2018-01-24 20:00:00 4 hr time horizon... +2026-04-29 10:15:13,095 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:15,466 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 14 hr time horizon... +2026-04-29 10:15:15,499 - __main__ - INFO - Processing values: 2018-01-09 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:16,086 - __main__ - INFO - Finished processing 2018-01-02 10:00:00 7 hr time horizon... +2026-04-29 10:15:16,113 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:16,448 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 17 hr time horizon... +2026-04-29 10:15:16,473 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:16,937 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:16,956 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:17,828 - __main__ - INFO - Finished processing 2018-01-28 01:00:00 5 hr time horizon... +2026-04-29 10:15:17,849 - __main__ - INFO - Processing values: 2018-01-03 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:18,186 - __main__ - INFO - Finished processing 2018-01-11 18:00:00 18 hr time horizon... +2026-04-29 10:15:18,196 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 7 hr time horizon... +2026-04-29 10:15:18,212 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 1 hr time horizon... +2026-04-29 10:15:18,221 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:18,465 - __main__ - INFO - Finished processing 2018-01-28 15:00:00 2 hr time horizon... +2026-04-29 10:15:18,484 - __main__ - INFO - Processing values: 2018-01-10 12:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:19,868 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 5 hr time horizon... +2026-04-29 10:15:19,890 - __main__ - INFO - Processing values: 2018-01-25 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:20,382 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 10 hr time horizon... +2026-04-29 10:15:20,404 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 9 hr time horizon... +2026-04-29 10:15:20,487 - __main__ - INFO - Finished processing 2018-01-03 17:00:00 15 hr time horizon... +2026-04-29 10:15:20,510 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:21,347 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 4 hr time horizon... +2026-04-29 10:15:21,371 - __main__ - INFO - Processing values: 2018-01-13 01:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:21,496 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 17 hr time horizon... +2026-04-29 10:15:21,516 - __main__ - INFO - Processing values: 2018-01-04 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:23,145 - __main__ - INFO - Finished processing 2018-01-23 09:00:00 13 hr time horizon... +2026-04-29 10:15:23,168 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:26,479 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 1 hr time horizon... +2026-04-29 10:15:26,499 - __main__ - INFO - Processing values: 2018-01-10 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:26,820 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 9 hr time horizon... +2026-04-29 10:15:26,841 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 3 hr time horizon... +2026-04-29 10:15:26,955 - __main__ - INFO - Finished processing 2018-01-25 01:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:26,977 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 9 hr time horizon... +2026-04-29 10:15:27,028 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:27,048 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 12 hr time horizon... +2026-04-29 10:15:27,083 - __main__ - INFO - Finished processing 2018-01-19 02:00:00 15 hr time horizon... +2026-04-29 10:15:27,103 - __main__ - INFO - Processing values: 2018-01-08 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:29,509 - __main__ - INFO - Finished processing 2018-01-09 21:00:00 7 hr time horizon... +2026-04-29 10:15:29,532 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:29,797 - __main__ - INFO - Finished processing 2018-01-04 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:29,817 - __main__ - INFO - Processing values: 2018-01-01 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:31,737 - __main__ - INFO - Finished processing 2018-01-03 05:00:00 15 hr time horizon... +2026-04-29 10:15:31,760 - __main__ - INFO - Processing values: 2018-01-28 18:00:00 4 hr time horizon... +2026-04-29 10:15:31,772 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 14 hr time horizon... +2026-04-29 10:15:31,805 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:32,759 - __main__ - INFO - Finished processing 2018-01-10 12:00:00 16 hr time horizon... +2026-04-29 10:15:32,781 - __main__ - INFO - Processing values: 2018-01-11 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:33,235 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 18 hr time horizon... +2026-04-29 10:15:33,260 - __main__ - INFO - Processing values: 2018-01-10 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:33,498 - __main__ - INFO - Finished processing 2018-01-20 05:00:00 1 hr time horizon... +2026-04-29 10:15:33,517 - __main__ - INFO - Processing values: 2018-01-26 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:35,070 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 9 hr time horizon... +2026-04-29 10:15:35,092 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:35,269 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 10 hr time horizon... +2026-04-29 10:15:35,292 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 2 hr time horizon... +2026-04-29 10:15:35,397 - __main__ - INFO - Finished processing 2018-01-25 07:00:00 3 hr time horizon... +2026-04-29 10:15:35,416 - __main__ - INFO - Processing values: 2018-01-03 11:00:00 3 hr time horizon... +2026-04-29 10:15:35,457 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 12 hr time horizon... +2026-04-29 10:15:35,496 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:35,584 - __main__ - INFO - Finished processing 2018-01-13 01:00:00 17 hr time horizon... +2026-04-29 10:15:35,603 - __main__ - INFO - Processing values: 2018-01-05 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:37,567 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 1 hr time horizon... +2026-04-29 10:15:37,588 - __main__ - INFO - Processing values: 2018-01-04 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:39,836 - __main__ - INFO - Finished processing 2018-01-04 02:00:00 11 hr time horizon... +2026-04-29 10:15:39,856 - __main__ - INFO - Processing values: 2018-01-03 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:41,204 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 9 hr time horizon... +2026-04-29 10:15:41,225 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 8 hr time horizon... +2026-04-29 10:15:41,275 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:15:41,304 - __main__ - INFO - Processing values: 2018-01-09 12:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:41,712 - __main__ - INFO - Finished processing 2018-01-08 22:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:41,736 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 12 hr time horizon... +2026-04-29 10:15:41,811 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 3 hr time horizon... +2026-04-29 10:15:41,830 - __main__ - INFO - Processing values: 2018-01-19 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:42,758 - __main__ - INFO - Finished processing 2018-01-10 18:00:00 4 hr time horizon... +2026-04-29 10:15:42,790 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:43,925 - __main__ - INFO - Finished processing 2018-01-01 12:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:43,950 - __main__ - INFO - Processing values: 2018-01-10 17:00:00 8 hr time horizon... +2026-04-29 10:15:44,115 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 6 hr time horizon... +2026-04-29 10:15:44,137 - __main__ - INFO - Processing values: 2018-01-10 16:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:45,810 - __main__ - INFO - Finished processing 2018-01-28 18:00:00 4 hr time horizon... +2026-04-29 10:15:45,830 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:46,504 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 3 hr time horizon... +2026-04-29 10:15:46,525 - __main__ - INFO - Processing values: 2018-01-09 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:48,097 - __main__ - INFO - Finished processing 2018-01-26 18:00:00 13 hr time horizon... +2026-04-29 10:15:48,120 - __main__ - INFO - Processing values: 2018-01-02 21:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:48,333 - __main__ - INFO - Finished processing 2018-01-10 20:00:00 2 hr time horizon... +2026-04-29 10:15:48,373 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:48,858 - __main__ - INFO - Finished processing 2018-01-11 08:00:00 15 hr time horizon... +2026-04-29 10:15:48,884 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:49,882 - __main__ - INFO - Finished processing 2018-01-03 11:00:00 3 hr time horizon... +2026-04-29 10:15:49,906 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:50,298 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 2 hr time horizon... +2026-04-29 10:15:50,323 - __main__ - INFO - Processing values: 2018-01-25 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:50,492 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 17 hr time horizon... +2026-04-29 10:15:50,515 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:50,807 - __main__ - INFO - Finished processing 2018-01-05 11:00:00 16 hr time horizon... +2026-04-29 10:15:50,829 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:51,795 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 8 hr time horizon... +2026-04-29 10:15:51,821 - __main__ - INFO - Processing values: 2018-01-24 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:52,893 - __main__ - INFO - Finished processing 2018-01-04 14:00:00 16 hr time horizon... +2026-04-29 10:15:52,916 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:55,948 - __main__ - INFO - Finished processing 2018-01-03 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:55,972 - __main__ - INFO - Processing values: 2018-01-13 08:00:00 13 hr time horizon... +2026-04-29 10:15:56,024 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 8 hr time horizon... +2026-04-29 10:15:56,049 - __main__ - INFO - Processing values: 2018-01-09 00:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:56,584 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 12 hr time horizon... +2026-04-29 10:15:56,603 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 12 hr time horizon... +2026-04-29 10:15:56,675 - __main__ - INFO - Finished processing 2018-01-09 12:00:00 8 hr time horizon... +2026-04-29 10:15:56,699 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:56,929 - __main__ - INFO - Finished processing 2018-01-19 21:00:00 14 hr time horizon... +2026-04-29 10:15:56,951 - __main__ - INFO - Processing values: 2018-01-14 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:57,134 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 6 hr time horizon... +2026-04-29 10:15:57,153 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:59,300 - __main__ - INFO - Finished processing 2018-01-10 16:00:00 3 hr time horizon... +2026-04-29 10:15:59,323 - __main__ - INFO - Processing values: 2018-01-29 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:15:59,441 - __main__ - INFO - Finished processing 2018-01-10 17:00:00 8 hr time horizon... +2026-04-29 10:15:59,462 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:00,443 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 5 hr time horizon... +2026-04-29 10:16:00,465 - __main__ - INFO - Processing values: 2018-01-18 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:01,259 - __main__ - INFO - Finished processing 2018-01-09 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:01,282 - __main__ - INFO - Processing values: 2018-01-07 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:02,437 - __main__ - INFO - Finished processing 2018-01-02 21:00:00 1 hr time horizon... +2026-04-29 10:16:02,462 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:02,850 - __main__ - INFO - Finished processing 2018-01-20 10:00:00 9 hr time horizon... +2026-04-29 10:16:02,877 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:03,520 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:03,550 - __main__ - INFO - Processing values: 2018-01-16 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:04,880 - __main__ - INFO - Finished processing 2018-01-25 11:00:00 5 hr time horizon... +2026-04-29 10:16:04,900 - __main__ - INFO - Processing values: 2018-01-12 06:00:00 12 hr time horizon... +2026-04-29 10:16:05,078 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 5 hr time horizon... +2026-04-29 10:16:05,099 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:05,188 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 7 hr time horizon... +2026-04-29 10:16:05,217 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 18 hr time horizon... +2026-04-29 10:16:05,763 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 15 hr time horizon... +2026-04-29 10:16:05,783 - __main__ - INFO - Processing values: 2018-01-24 16:00:00 14 hr time horizon... +2026-04-29 10:16:05,786 - __main__ - INFO - Finished processing 2018-01-24 10:00:00 17 hr time horizon... +2026-04-29 10:16:05,804 - __main__ - INFO - Processing values: 2018-01-07 02:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:08,957 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:08,986 - __main__ - INFO - Processing values: 2018-01-02 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:09,758 - __main__ - INFO - Finished processing 2018-01-13 08:00:00 13 hr time horizon... +2026-04-29 10:16:09,779 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:10,734 - __main__ - INFO - Finished processing 2018-01-09 00:00:00 10 hr time horizon... +2026-04-29 10:16:10,760 - __main__ - INFO - Processing values: 2018-01-24 18:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:10,993 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 15 hr time horizon... +2026-04-29 10:16:11,016 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:11,593 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 17 hr time horizon... +2026-04-29 10:16:11,615 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:11,742 - __main__ - INFO - Finished processing 2018-01-14 14:00:00 12 hr time horizon... +2026-04-29 10:16:11,765 - __main__ - INFO - Processing values: 2018-01-12 09:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:12,124 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 12 hr time horizon... +2026-04-29 10:16:12,145 - __main__ - INFO - Processing values: 2018-01-23 05:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:13,415 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 12 hr time horizon... +2026-04-29 10:16:13,440 - __main__ - INFO - Processing values: 2018-01-06 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:15,090 - __main__ - INFO - Finished processing 2018-01-18 21:00:00 12 hr time horizon... +2026-04-29 10:16:15,115 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:16,068 - __main__ - INFO - Finished processing 2018-01-29 14:00:00 13 hr time horizon... +2026-04-29 10:16:16,092 - __main__ - INFO - Processing values: 2018-01-29 04:00:00 11 hr time horizon... +2026-04-29 10:16:16,180 - __main__ - INFO - Finished processing 2018-01-07 05:00:00 11 hr time horizon... +2026-04-29 10:16:16,207 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:16,453 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 7 hr time horizon... +2026-04-29 10:16:16,473 - __main__ - INFO - Processing values: 2018-01-02 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:16,879 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 7 hr time horizon... +2026-04-29 10:16:16,901 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:17,779 - __main__ - INFO - Finished processing 2018-01-16 00:00:00 5 hr time horizon... +2026-04-29 10:16:17,798 - __main__ - INFO - Processing values: 2018-01-10 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:20,154 - __main__ - INFO - Finished processing 2018-01-12 06:00:00 12 hr time horizon... +2026-04-29 10:16:20,177 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 15 hr time horizon... +2026-04-29 10:16:20,252 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 1 hr time horizon... +2026-04-29 10:16:20,268 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:20,389 - __main__ - INFO - Finished processing 2018-01-07 02:00:00 7 hr time horizon... +2026-04-29 10:16:20,409 - __main__ - INFO - Processing values: 2018-01-12 02:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:21,003 - __main__ - INFO - Finished processing 2018-01-24 16:00:00 14 hr time horizon... +2026-04-29 10:16:21,022 - __main__ - INFO - Processing values: 2018-01-16 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:21,961 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 18 hr time horizon... +2026-04-29 10:16:21,987 - __main__ - INFO - Processing values: 2018-01-27 06:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:27,801 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 9 hr time horizon... +2026-04-29 10:16:27,802 - __main__ - INFO - Finished processing 2018-01-24 18:00:00 17 hr time horizon... +2026-04-29 10:16:27,806 - __main__ - INFO - Finished processing 2018-01-23 05:00:00 8 hr time horizon... +2026-04-29 10:16:27,837 - __main__ - INFO - Processing values: 2018-01-04 19:00:00 8 hr time horizon... +2026-04-29 10:16:27,843 - __main__ - INFO - Processing values: 2018-01-15 02:00:00 18 hr time horizon... +2026-04-29 10:16:27,843 - __main__ - INFO - Processing values: 2018-01-28 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:30,800 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 9 hr time horizon... +2026-04-29 10:16:30,817 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:32,947 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 3 hr time horizon... +2026-04-29 10:16:32,964 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:36,126 - __main__ - INFO - Finished processing 2018-01-02 16:00:00 18 hr time horizon... +2026-04-29 10:16:36,144 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:40,677 - __main__ - INFO - Finished processing 2018-01-15 02:00:00 18 hr time horizon... +2026-04-29 10:16:40,697 - __main__ - INFO - Processing values: 2018-01-25 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:40,804 - __main__ - INFO - Finished processing 2018-01-28 08:00:00 4 hr time horizon... +2026-04-29 10:16:40,821 - __main__ - INFO - Processing values: 2018-01-19 12:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:43,219 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 2 hr time horizon... +2026-04-29 10:16:43,235 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 9 hr time horizon... +2026-04-29 10:16:43,312 - __main__ - INFO - Finished processing 2018-01-04 19:00:00 8 hr time horizon... +2026-04-29 10:16:43,329 - __main__ - INFO - Processing values: 2018-01-06 03:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:46,191 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 11 hr time horizon... +2026-04-29 10:16:46,209 - __main__ - INFO - Processing values: 2018-01-05 08:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:48,665 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 3 hr time horizon... +2026-04-29 10:16:48,683 - __main__ - INFO - Processing values: 2018-01-17 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:54,723 - __main__ - INFO - Finished processing 2018-01-25 14:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:54,740 - __main__ - INFO - Processing values: 2018-01-18 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:56,297 - __main__ - INFO - Finished processing 2018-01-19 12:00:00 6 hr time horizon... +2026-04-29 10:16:56,315 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 4 hr time horizon... +2026-04-29 10:16:56,323 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 9 hr time horizon... +2026-04-29 10:16:56,341 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:57,233 - __main__ - INFO - Finished processing 2018-01-06 03:00:00 5 hr time horizon... +2026-04-29 10:16:57,251 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:16:58,954 - __main__ - INFO - Finished processing 2018-01-05 08:00:00 16 hr time horizon... +2026-04-29 10:16:58,973 - __main__ - INFO - Processing values: 2018-01-01 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:02,982 - __main__ - INFO - Finished processing 2018-01-17 22:00:00 2 hr time horizon... +2026-04-29 10:17:02,999 - __main__ - INFO - Processing values: 2018-01-04 18:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:09,341 - __main__ - INFO - Finished processing 2018-01-16 22:00:00 11 hr time horizon... +2026-04-29 10:17:09,361 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:10,003 - __main__ - INFO - Finished processing 2018-01-18 06:00:00 5 hr time horizon... +2026-04-29 10:17:10,021 - __main__ - INFO - Processing values: 2018-01-19 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:12,820 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:12,841 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:13,623 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 3 hr time horizon... +2026-04-29 10:17:13,640 - __main__ - INFO - Processing values: 2018-01-10 15:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:14,137 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:14,161 - __main__ - INFO - Processing values: 2018-01-16 06:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:15,198 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 3 hr time horizon... +2026-04-29 10:17:15,218 - __main__ - INFO - Processing values: 2018-01-17 18:00:00 2 hr time horizon... +2026-04-29 10:17:15,674 - __main__ - INFO - Finished processing 2018-01-29 04:00:00 11 hr time horizon... +2026-04-29 10:17:15,692 - __main__ - INFO - Processing values: 2018-01-06 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:19,872 - __main__ - INFO - Finished processing 2018-01-12 02:00:00 16 hr time horizon... +2026-04-29 10:17:19,892 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:21,072 - __main__ - INFO - Finished processing 2018-01-02 04:00:00 11 hr time horizon... +2026-04-29 10:17:21,091 - __main__ - INFO - Processing values: 2018-01-17 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:22,564 - __main__ - INFO - Finished processing 2018-01-19 07:00:00 2 hr time horizon... +2026-04-29 10:17:22,582 - __main__ - INFO - Processing values: 2018-01-24 11:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:23,984 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 12 hr time horizon... +2026-04-29 10:17:24,010 - __main__ - INFO - Processing values: 2018-01-21 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:24,769 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:24,790 - __main__ - INFO - Processing values: 2018-01-12 04:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:25,734 - __main__ - INFO - Finished processing 2018-01-01 04:00:00 11 hr time horizon... +2026-04-29 10:17:25,752 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:27,560 - __main__ - INFO - Finished processing 2018-01-10 19:00:00 14 hr time horizon... +2026-04-29 10:17:27,584 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:27,599 - __main__ - INFO - Finished processing 2018-01-16 06:00:00 6 hr time horizon... +2026-04-29 10:17:27,621 - __main__ - INFO - Processing values: 2018-01-09 14:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:27,718 - __main__ - INFO - Finished processing 2018-01-10 15:00:00 2 hr time horizon... +2026-04-29 10:17:27,740 - __main__ - INFO - Processing values: 2018-01-08 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:27,798 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 18 hr time horizon... +2026-04-29 10:17:27,819 - __main__ - INFO - Processing values: 2018-01-17 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:28,173 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 10 hr time horizon... +2026-04-29 10:17:28,191 - __main__ - INFO - Processing values: 2018-01-12 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:29,009 - __main__ - INFO - Finished processing 2018-01-17 18:00:00 2 hr time horizon... +2026-04-29 10:17:29,026 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 5 hr time horizon... +2026-04-29 10:17:29,218 - __main__ - INFO - Finished processing 2018-01-06 08:00:00 12 hr time horizon... +2026-04-29 10:17:29,242 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:34,695 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:34,719 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:35,306 - __main__ - INFO - Finished processing 2018-01-17 01:00:00 10 hr time horizon... +2026-04-29 10:17:35,328 - __main__ - INFO - Processing values: 2018-01-04 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:36,839 - __main__ - INFO - Finished processing 2018-01-24 11:00:00 13 hr time horizon... +2026-04-29 10:17:36,859 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:37,010 - __main__ - INFO - Finished processing 2018-01-27 06:00:00 11 hr time horizon... +2026-04-29 10:17:37,035 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 12 hr time horizon... +2026-04-29 10:17:37,535 - __main__ - INFO - Finished processing 2018-01-21 12:00:00 7 hr time horizon... +2026-04-29 10:17:37,560 - __main__ - INFO - Processing values: 2018-01-11 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:40,792 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 7 hr time horizon... +2026-04-29 10:17:40,813 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 6 hr time horizon... +2026-04-29 10:17:40,843 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 4 hr time horizon... +2026-04-29 10:17:40,864 - __main__ - INFO - Processing values: 2018-01-21 08:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:40,961 - __main__ - INFO - Finished processing 2018-01-09 14:00:00 4 hr time horizon... +2026-04-29 10:17:40,986 - __main__ - INFO - Processing values: 2018-01-08 08:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:41,211 - __main__ - INFO - Finished processing 2018-01-17 03:00:00 13 hr time horizon... +2026-04-29 10:17:41,235 - __main__ - INFO - Processing values: 2018-01-12 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:41,684 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 2 hr time horizon... +2026-04-29 10:17:41,701 - __main__ - INFO - Processing values: 2018-01-04 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:42,517 - __main__ - INFO - Finished processing 2018-01-12 04:00:00 17 hr time horizon... +2026-04-29 10:17:42,543 - __main__ - INFO - Processing values: 2018-01-26 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:43,572 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 5 hr time horizon... +2026-04-29 10:17:43,591 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:45,207 - __main__ - INFO - Finished processing 2018-01-12 08:00:00 8 hr time horizon... +2026-04-29 10:17:45,230 - __main__ - INFO - Processing values: 2018-01-07 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:47,059 - __main__ - INFO - Finished processing 2018-01-08 13:00:00 10 hr time horizon... +2026-04-29 10:17:47,086 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:48,526 - __main__ - INFO - Finished processing 2018-01-04 20:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:48,554 - __main__ - INFO - Processing values: 2018-01-01 22:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:48,762 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 8 hr time horizon... +2026-04-29 10:17:48,783 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:49,523 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 7 hr time horizon... +2026-04-29 10:17:49,542 - __main__ - INFO - Processing values: 2018-01-11 17:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:50,131 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 12 hr time horizon... +2026-04-29 10:17:50,159 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:51,238 - __main__ - INFO - Finished processing 2018-01-11 03:00:00 2 hr time horizon... +2026-04-29 10:17:51,265 - __main__ - INFO - Processing values: 2018-01-25 05:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:51,710 - __main__ - INFO - Finished processing 2018-01-06 20:00:00 13 hr time horizon... +2026-04-29 10:17:51,739 - __main__ - INFO - Processing values: 2018-01-22 10:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:52,730 - __main__ - INFO - Finished processing 2018-01-12 09:00:00 12 hr time horizon... +2026-04-29 10:17:52,757 - __main__ - INFO - Processing values: 2018-01-14 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:54,311 - __main__ - INFO - Finished processing 2018-01-21 08:00:00 3 hr time horizon... +2026-04-29 10:17:54,334 - __main__ - INFO - Processing values: 2018-01-19 23:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:55,093 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 6 hr time horizon... +2026-04-29 10:17:55,108 - __main__ - INFO - Finished processing 2018-01-12 07:00:00 5 hr time horizon... +2026-04-29 10:17:55,115 - __main__ - INFO - Processing values: 2018-01-18 22:00:00 3 hr time horizon... +2026-04-29 10:17:55,130 - __main__ - INFO - Processing values: 2018-01-02 23:00:00 8 hr time horizon... +2026-04-29 10:17:55,132 - __main__ - INFO - Finished processing 2018-01-08 08:00:00 12 hr time horizon... +2026-04-29 10:17:55,158 - __main__ - INFO - Processing values: 2018-01-28 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:58,902 - __main__ - INFO - Finished processing 2018-01-04 00:00:00 9 hr time horizon... +2026-04-29 10:17:58,927 - __main__ - INFO - Processing values: 2018-01-07 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:59,090 - __main__ - INFO - Finished processing 2018-01-26 19:00:00 12 hr time horizon... +2026-04-29 10:17:59,113 - __main__ - INFO - Processing values: 2018-01-17 20:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:17:59,654 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 10 hr time horizon... +2026-04-29 10:17:59,675 - __main__ - INFO - Processing values: 2018-01-12 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:00,471 - __main__ - INFO - Finished processing 2018-01-07 01:00:00 12 hr time horizon... +2026-04-29 10:18:00,497 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:01,012 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 11 hr time horizon... +2026-04-29 10:18:01,034 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:01,878 - __main__ - INFO - Finished processing 2018-01-01 22:00:00 9 hr time horizon... +2026-04-29 10:18:01,897 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:04,880 - __main__ - INFO - Finished processing 2018-01-11 17:00:00 2 hr time horizon... +2026-04-29 10:18:04,905 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:05,079 - __main__ - INFO - Finished processing 2018-01-14 21:00:00 6 hr time horizon... +2026-04-29 10:18:05,099 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:05,455 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 12 hr time horizon... +2026-04-29 10:18:05,478 - __main__ - INFO - Processing values: 2018-01-22 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:05,962 - __main__ - INFO - Finished processing 2018-01-25 05:00:00 4 hr time horizon... +2026-04-29 10:18:05,986 - __main__ - INFO - Processing values: 2018-01-08 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:06,582 - __main__ - INFO - Finished processing 2018-01-22 10:00:00 5 hr time horizon... +2026-04-29 10:18:06,608 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 12 hr time horizon... +2026-04-29 10:18:06,712 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 8 hr time horizon... +2026-04-29 10:18:06,741 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:06,965 - __main__ - INFO - Finished processing 2018-01-14 02:00:00 10 hr time horizon... +2026-04-29 10:18:06,987 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:09,851 - __main__ - INFO - Finished processing 2018-01-28 14:00:00 1 hr time horizon... +2026-04-29 10:18:09,873 - __main__ - INFO - Processing values: 2018-01-29 02:00:00 3 hr time horizon... +2026-04-29 10:18:10,026 - __main__ - INFO - Finished processing 2018-01-18 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:10,058 - __main__ - INFO - Processing values: 2018-01-15 12:00:00 1 hr time horizon... +2026-04-29 10:18:10,268 - __main__ - INFO - Finished processing 2018-01-02 23:00:00 8 hr time horizon... +2026-04-29 10:18:10,293 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 11 hr time horizon... +2026-04-29 10:18:10,667 - __main__ - INFO - Finished processing 2018-01-04 18:00:00 18 hr time horizon... +2026-04-29 10:18:10,690 - __main__ - INFO - Processing values: 2018-01-20 16:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:14,388 - __main__ - INFO - Finished processing 2018-01-17 20:00:00 9 hr time horizon... +2026-04-29 10:18:14,410 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:14,467 - __main__ - INFO - Finished processing 2018-01-07 07:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:14,493 - __main__ - INFO - Processing values: 2018-01-30 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:14,995 - __main__ - INFO - Finished processing 2018-01-12 10:00:00 1 hr time horizon... +2026-04-29 10:18:15,016 - __main__ - INFO - Processing values: 2018-01-13 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:15,590 - __main__ - INFO - Finished processing 2018-01-19 23:00:00 14 hr time horizon... +2026-04-29 10:18:15,617 - __main__ - INFO - Processing values: 2018-01-12 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:15,747 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 7 hr time horizon... +2026-04-29 10:18:15,770 - __main__ - INFO - Processing values: 2018-01-01 14:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:16,341 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 6 hr time horizon... +2026-04-29 10:18:16,363 - __main__ - INFO - Processing values: 2018-01-10 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:16,619 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 18 hr time horizon... +2026-04-29 10:18:16,647 - __main__ - INFO - Processing values: 2018-01-11 09:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:17,216 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 8 hr time horizon... +2026-04-29 10:18:17,240 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:19,713 - __main__ - INFO - Finished processing 2018-01-22 07:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:19,739 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 18 hr time horizon... +2026-04-29 10:18:19,894 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 1 hr time horizon... +2026-04-29 10:18:19,914 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:20,276 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 4 hr time horizon... +2026-04-29 10:18:20,304 - __main__ - INFO - Processing values: 2018-01-14 03:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:22,159 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 4 hr time horizon... +2026-04-29 10:18:22,182 - __main__ - INFO - Processing values: 2018-01-28 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:22,495 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 17 hr time horizon... +2026-04-29 10:18:22,515 - __main__ - INFO - Processing values: 2018-01-30 20:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:22,773 - __main__ - INFO - Finished processing 2018-01-08 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:22,799 - __main__ - INFO - Processing values: 2018-01-21 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:23,217 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 12 hr time horizon... +2026-04-29 10:18:23,240 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:24,611 - __main__ - INFO - Finished processing 2018-01-15 12:00:00 1 hr time horizon... +2026-04-29 10:18:24,630 - __main__ - INFO - Processing values: 2018-01-18 15:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:25,007 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 11 hr time horizon... +2026-04-29 10:18:25,042 - __main__ - INFO - Processing values: 2018-01-09 08:00:00 8 hr time horizon... +2026-04-29 10:18:25,577 - __main__ - INFO - Finished processing 2018-01-29 02:00:00 3 hr time horizon... +2026-04-29 10:18:25,595 - __main__ - INFO - Processing values: 2018-01-15 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:29,737 - __main__ - INFO - Finished processing 2018-01-20 16:00:00 11 hr time horizon... +2026-04-29 10:18:29,761 - __main__ - INFO - Processing values: 2018-01-30 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:30,044 - __main__ - INFO - Finished processing 2018-01-30 23:00:00 18 hr time horizon... +2026-04-29 10:18:30,068 - __main__ - INFO - Processing values: 2018-01-26 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:30,115 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 10 hr time horizon... +2026-04-29 10:18:30,138 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 17 hr time horizon... +2026-04-29 10:18:30,168 - __main__ - INFO - Finished processing 2018-01-13 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:30,191 - __main__ - INFO - Processing values: 2018-01-16 10:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:30,748 - __main__ - INFO - Finished processing 2018-01-01 14:00:00 11 hr time horizon... +2026-04-29 10:18:30,770 - __main__ - INFO - Processing values: 2018-01-14 22:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:30,941 - __main__ - INFO - Finished processing 2018-01-12 12:00:00 1 hr time horizon... +2026-04-29 10:18:30,963 - __main__ - INFO - Processing values: 2018-01-13 23:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:32,266 - __main__ - INFO - Finished processing 2018-01-11 09:00:00 6 hr time horizon... +2026-04-29 10:18:32,289 - __main__ - INFO - Processing values: 2018-01-11 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:33,692 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 9 hr time horizon... +2026-04-29 10:18:33,713 - __main__ - INFO - Processing values: 2018-01-22 13:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:33,815 - __main__ - INFO - Finished processing 2018-01-10 07:00:00 11 hr time horizon... +2026-04-29 10:18:33,839 - __main__ - INFO - Processing values: 2018-01-02 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:34,947 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:34,969 - __main__ - INFO - Processing values: 2018-01-04 16:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:35,502 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 12 hr time horizon... +2026-04-29 10:18:35,524 - __main__ - INFO - Processing values: 2018-01-17 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:36,105 - __main__ - INFO - Finished processing 2018-01-14 03:00:00 17 hr time horizon... +2026-04-29 10:18:36,128 - __main__ - INFO - Processing values: 2018-01-02 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:37,196 - __main__ - INFO - Finished processing 2018-01-30 20:00:00 1 hr time horizon... +2026-04-29 10:18:37,217 - __main__ - INFO - Processing values: 2018-01-20 23:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:38,125 - __main__ - INFO - Finished processing 2018-01-21 04:00:00 13 hr time horizon... +2026-04-29 10:18:38,148 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:38,251 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 18 hr time horizon... +2026-04-29 10:18:38,273 - __main__ - INFO - Processing values: 2018-01-29 06:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:39,488 - __main__ - INFO - Finished processing 2018-01-18 15:00:00 18 hr time horizon... +2026-04-29 10:18:39,513 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:42,494 - __main__ - INFO - Finished processing 2018-01-28 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:42,518 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:43,821 - __main__ - INFO - Finished processing 2018-01-30 19:00:00 8 hr time horizon... +2026-04-29 10:18:43,844 - __main__ - INFO - Processing values: 2018-01-18 05:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:43,864 - __main__ - INFO - Finished processing 2018-01-16 10:00:00 1 hr time horizon... +2026-04-29 10:18:43,881 - __main__ - INFO - Processing values: 2018-01-31 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:44,123 - __main__ - INFO - Finished processing 2018-01-13 23:00:00 5 hr time horizon... +2026-04-29 10:18:44,139 - __main__ - INFO - Processing values: 2018-01-01 01:00:00 16 hr time horizon... +2026-04-29 10:18:44,153 - __main__ - INFO - Finished processing 2018-01-09 08:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:44,180 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:44,721 - __main__ - INFO - Finished processing 2018-01-26 14:00:00 12 hr time horizon... +2026-04-29 10:18:44,740 - __main__ - INFO - Processing values: 2018-01-13 13:00:00 14 hr time horizon... +2026-04-29 10:18:44,775 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 17 hr time horizon... +2026-04-29 10:18:44,795 - __main__ - INFO - Processing values: 2018-01-26 05:00:00 15 hr time horizon... +2026-04-29 10:18:44,827 - __main__ - INFO - Finished processing 2018-01-15 06:00:00 16 hr time horizon... +2026-04-29 10:18:44,850 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:46,322 - __main__ - INFO - Finished processing 2018-01-11 22:00:00 4 hr time horizon... +2026-04-29 10:18:46,346 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:47,612 - __main__ - INFO - Finished processing 2018-01-22 13:00:00 14 hr time horizon... +2026-04-29 10:18:47,641 - __main__ - INFO - Processing values: 2018-01-03 00:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:48,729 - __main__ - INFO - Finished processing 2018-01-04 16:00:00 5 hr time horizon... +2026-04-29 10:18:48,732 - __main__ - INFO - Finished processing 2018-01-02 02:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:48,760 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 11 hr time horizon... +2026-04-29 10:18:48,763 - __main__ - INFO - Processing values: 2018-01-25 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:50,429 - __main__ - INFO - Finished processing 2018-01-17 21:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:50,455 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 2 hr time horizon... +2026-04-29 10:18:50,608 - __main__ - INFO - Finished processing 2018-01-14 22:00:00 3 hr time horizon... +2026-04-29 10:18:50,627 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:52,257 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 12 hr time horizon... +2026-04-29 10:18:52,279 - __main__ - INFO - Processing values: 2018-01-23 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:53,002 - __main__ - INFO - Finished processing 2018-01-29 06:00:00 3 hr time horizon... +2026-04-29 10:18:53,022 - __main__ - INFO - Processing values: 2018-01-21 20:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:54,824 - __main__ - INFO - Finished processing 2018-01-02 05:00:00 14 hr time horizon... +2026-04-29 10:18:54,846 - __main__ - INFO - Processing values: 2018-01-08 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:56,335 - __main__ - INFO - Finished processing 2018-01-20 23:00:00 3 hr time horizon... +2026-04-29 10:18:56,354 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:57,415 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 5 hr time horizon... +2026-04-29 10:18:57,440 - __main__ - INFO - Processing values: 2018-01-16 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:58,487 - __main__ - INFO - Finished processing 2018-01-01 01:00:00 16 hr time horizon... +2026-04-29 10:18:58,509 - __main__ - INFO - Processing values: 2018-01-22 01:00:00 8 hr time horizon... +2026-04-29 10:18:58,547 - __main__ - INFO - Finished processing 2018-01-31 00:00:00 7 hr time horizon... +2026-04-29 10:18:58,574 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 11 hr time horizon... +2026-04-29 10:18:58,601 - __main__ - INFO - Finished processing 2018-01-13 13:00:00 14 hr time horizon... +2026-04-29 10:18:58,621 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:18:58,746 - __main__ - INFO - Finished processing 2018-01-28 13:00:00 10 hr time horizon... +2026-04-29 10:18:58,767 - __main__ - INFO - Processing values: 2018-01-04 13:00:00 17 hr time horizon... +2026-04-29 10:18:58,789 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 10 hr time horizon... +2026-04-29 10:18:58,811 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:00,950 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 6 hr time horizon... +2026-04-29 10:19:00,970 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:01,547 - __main__ - INFO - Finished processing 2018-01-26 05:00:00 15 hr time horizon... +2026-04-29 10:19:01,564 - __main__ - INFO - Finished processing 2018-01-18 05:00:00 15 hr time horizon... +2026-04-29 10:19:01,575 - __main__ - INFO - Processing values: 2018-01-28 10:00:00 15 hr time horizon... +2026-04-29 10:19:01,590 - __main__ - INFO - Processing values: 2018-01-13 21:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:01,749 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 7 hr time horizon... +2026-04-29 10:19:01,770 - __main__ - INFO - Processing values: 2018-01-18 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:02,843 - __main__ - INFO - Finished processing 2018-01-03 00:00:00 7 hr time horizon... +2026-04-29 10:19:02,871 - __main__ - INFO - Processing values: 2018-01-08 20:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:03,878 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 11 hr time horizon... +2026-04-29 10:19:03,902 - __main__ - INFO - Processing values: 2018-01-24 06:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:04,269 - __main__ - INFO - Finished processing 2018-01-25 04:00:00 13 hr time horizon... +2026-04-29 10:19:04,291 - __main__ - INFO - Processing values: 2018-01-13 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:05,953 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:05,973 - __main__ - INFO - Processing values: 2018-01-27 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:07,020 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 2 hr time horizon... +2026-04-29 10:19:07,039 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:08,056 - __main__ - INFO - Finished processing 2018-01-23 15:00:00 14 hr time horizon... +2026-04-29 10:19:08,080 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:08,946 - __main__ - INFO - Finished processing 2018-01-21 20:00:00 11 hr time horizon... +2026-04-29 10:19:08,967 - __main__ - INFO - Processing values: 2018-01-18 01:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:10,204 - __main__ - INFO - Finished processing 2018-01-08 21:00:00 3 hr time horizon... +2026-04-29 10:19:10,236 - __main__ - INFO - Processing values: 2018-01-12 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:12,559 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 12 hr time horizon... +2026-04-29 10:19:12,582 - __main__ - INFO - Processing values: 2018-01-28 03:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:12,826 - __main__ - INFO - Finished processing 2018-01-16 21:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:12,853 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:13,358 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 11 hr time horizon... +2026-04-29 10:19:13,383 - __main__ - INFO - Processing values: 2018-01-09 20:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:13,475 - __main__ - INFO - Finished processing 2018-01-04 13:00:00 17 hr time horizon... +2026-04-29 10:19:13,501 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:13,511 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 10 hr time horizon... +2026-04-29 10:19:13,531 - __main__ - INFO - Processing values: 2018-01-12 22:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:14,516 - __main__ - INFO - Finished processing 2018-01-22 01:00:00 8 hr time horizon... +2026-04-29 10:19:14,539 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:14,914 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 14 hr time horizon... +2026-04-29 10:19:14,938 - __main__ - INFO - Processing values: 2018-01-12 16:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:15,492 - __main__ - INFO - Finished processing 2018-01-13 21:00:00 3 hr time horizon... +2026-04-29 10:19:15,510 - __main__ - INFO - Processing values: 2018-01-02 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:15,769 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 7 hr time horizon... +2026-04-29 10:19:15,788 - __main__ - INFO - Processing values: 2018-01-03 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:16,807 - __main__ - INFO - Finished processing 2018-01-28 10:00:00 15 hr time horizon... +2026-04-29 10:19:16,829 - __main__ - INFO - Processing values: 2018-01-13 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:19:17,426 - __main__ - INFO - Finished processing 2018-01-18 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:17,455 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:18,811 - __main__ - INFO - Finished processing 2018-01-08 20:00:00 10 hr time horizon... +2026-04-29 10:19:18,835 - __main__ - INFO - Processing values: 2018-01-17 08:00:00 10 hr time horizon... +2026-04-29 10:19:19,014 - __main__ - INFO - Finished processing 2018-01-24 06:00:00 10 hr time horizon... +2026-04-29 10:19:19,035 - __main__ - INFO - Processing values: 2018-01-22 05:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:19,234 - __main__ - INFO - Finished processing 2018-01-13 19:00:00 13 hr time horizon... +2026-04-29 10:19:19,255 - __main__ - INFO - Processing values: 2018-01-11 21:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:21,301 - __main__ - INFO - Finished processing 2018-01-27 07:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:21,323 - __main__ - INFO - Processing values: 2018-01-27 16:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:22,017 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:22,038 - __main__ - INFO - Processing values: 2018-01-25 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:23,476 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 18 hr time horizon... +2026-04-29 10:19:23,498 - __main__ - INFO - Processing values: 2018-01-08 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:24,156 - __main__ - INFO - Finished processing 2018-01-18 01:00:00 4 hr time horizon... +2026-04-29 10:19:24,178 - __main__ - INFO - Processing values: 2018-01-11 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:25,727 - __main__ - INFO - Finished processing 2018-01-12 03:00:00 10 hr time horizon... +2026-04-29 10:19:25,749 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:27,400 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 3 hr time horizon... +2026-04-29 10:19:27,421 - __main__ - INFO - Processing values: 2018-01-05 20:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:27,502 - __main__ - INFO - Finished processing 2018-01-12 22:00:00 5 hr time horizon... +2026-04-29 10:19:27,529 - __main__ - INFO - Processing values: 2018-01-27 13:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:27,641 - __main__ - INFO - Finished processing 2018-01-09 20:00:00 7 hr time horizon... +2026-04-29 10:19:27,665 - __main__ - INFO - Processing values: 2018-01-21 00:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:27,836 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 16 hr time horizon... +2026-04-29 10:19:27,858 - __main__ - INFO - Processing values: 2018-01-22 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:29,510 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:29,535 - __main__ - INFO - Processing values: 2018-01-08 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:19:29,847 - __main__ - INFO - Finished processing 2018-01-03 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:29,869 - __main__ - INFO - Processing values: 2018-01-04 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:30,019 - __main__ - INFO - Finished processing 2018-01-28 03:00:00 11 hr time horizon... +2026-04-29 10:19:30,041 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 14 hr time horizon... +2026-04-29 10:19:30,167 - __main__ - INFO - Finished processing 2018-01-12 16:00:00 6 hr time horizon... +2026-04-29 10:19:30,188 - __main__ - INFO - Processing values: 2018-01-12 01:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:30,253 - __main__ - INFO - Finished processing 2018-01-13 22:00:00 7 hr time horizon... +2026-04-29 10:19:30,271 - __main__ - INFO - Processing values: 2018-01-01 20:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:30,834 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 1 hr time horizon... +2026-04-29 10:19:30,857 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:19:31,215 - __main__ - INFO - Finished processing 2018-01-02 11:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:31,240 - __main__ - INFO - Processing values: 2018-01-05 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:33,276 - __main__ - INFO - Finished processing 2018-01-17 08:00:00 10 hr time horizon... +2026-04-29 10:19:33,302 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:33,428 - __main__ - INFO - Finished processing 2018-01-22 05:00:00 6 hr time horizon... +2026-04-29 10:19:33,453 - __main__ - INFO - Processing values: 2018-01-24 19:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:33,869 - __main__ - INFO - Finished processing 2018-01-11 21:00:00 7 hr time horizon... +2026-04-29 10:19:33,891 - __main__ - INFO - Processing values: 2018-01-17 15:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:36,034 - __main__ - INFO - Finished processing 2018-01-27 16:00:00 18 hr time horizon... +2026-04-29 10:19:36,057 - __main__ - INFO - Processing values: 2018-01-30 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:36,383 - __main__ - INFO - Finished processing 2018-01-25 18:00:00 14 hr time horizon... +2026-04-29 10:19:36,404 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:38,816 - __main__ - INFO - Finished processing 2018-01-08 10:00:00 18 hr time horizon... +2026-04-29 10:19:38,841 - __main__ - INFO - Processing values: 2018-01-07 11:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:39,263 - __main__ - INFO - Finished processing 2018-01-11 14:00:00 5 hr time horizon... +2026-04-29 10:19:39,289 - __main__ - INFO - Processing values: 2018-01-23 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:40,525 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 11 hr time horizon... +2026-04-29 10:19:40,554 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:41,908 - __main__ - INFO - Finished processing 2018-01-21 00:00:00 18 hr time horizon... +2026-04-29 10:19:41,932 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:42,037 - __main__ - INFO - Finished processing 2018-01-05 20:00:00 18 hr time horizon... +2026-04-29 10:19:42,063 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:44,444 - __main__ - INFO - Finished processing 2018-01-04 11:00:00 16 hr time horizon... +2026-04-29 10:19:44,470 - __main__ - INFO - Processing values: 2018-01-30 15:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:44,613 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 5 hr time horizon... +2026-04-29 10:19:44,635 - __main__ - INFO - Processing values: 2018-01-22 03:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:44,778 - __main__ - INFO - Finished processing 2018-01-12 01:00:00 12 hr time horizon... +2026-04-29 10:19:44,802 - __main__ - INFO - Processing values: 2018-01-25 22:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:44,926 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 14 hr time horizon... +2026-04-29 10:19:44,946 - __main__ - INFO - Processing values: 2018-01-13 10:00:00 8 hr time horizon... +2026-04-29 10:19:44,959 - __main__ - INFO - Finished processing 2018-01-01 20:00:00 14 hr time horizon... +2026-04-29 10:19:44,980 - __main__ - INFO - Processing values: 2018-01-17 13:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:45,424 - __main__ - INFO - Finished processing 2018-01-05 01:00:00 9 hr time horizon... +2026-04-29 10:19:45,443 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:45,947 - __main__ - INFO - Finished processing 2018-01-08 06:00:00 15 hr time horizon... +2026-04-29 10:19:45,977 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:46,303 - __main__ - INFO - Finished processing 2018-01-27 13:00:00 13 hr time horizon... +2026-04-29 10:19:46,327 - __main__ - INFO - Processing values: 2018-01-09 05:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:48,345 - __main__ - INFO - Finished processing 2018-01-24 19:00:00 1 hr time horizon... +2026-04-29 10:19:48,366 - __main__ - INFO - Processing values: 2018-01-05 19:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:49,109 - __main__ - INFO - Finished processing 2018-01-17 15:00:00 14 hr time horizon... +2026-04-29 10:19:49,130 - __main__ - INFO - Processing values: 2018-01-21 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:50,222 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 15 hr time horizon... +2026-04-29 10:19:50,247 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:53,755 - __main__ - INFO - Finished processing 2018-01-07 11:00:00 16 hr time horizon... +2026-04-29 10:19:53,786 - __main__ - INFO - Processing values: 2018-01-30 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:53,941 - __main__ - INFO - Finished processing 2018-01-30 09:00:00 1 hr time horizon... +2026-04-29 10:19:53,962 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:54,076 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 1 hr time horizon... +2026-04-29 10:19:54,094 - __main__ - INFO - Processing values: 2018-01-15 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:55,074 - __main__ - INFO - Finished processing 2018-01-23 02:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:55,101 - __main__ - INFO - Processing values: 2018-01-28 23:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:55,608 - __main__ - INFO - Finished processing 2018-01-22 09:00:00 8 hr time horizon... +2026-04-29 10:19:55,630 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,038 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,061 - __main__ - INFO - Processing values: 2018-01-27 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,108 - __main__ - INFO - Finished processing 2018-01-19 01:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,131 - __main__ - INFO - Processing values: 2018-01-06 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,365 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:57,388 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:59,318 - __main__ - INFO - Finished processing 2018-01-25 22:00:00 16 hr time horizon... +2026-04-29 10:19:59,345 - __main__ - INFO - Processing values: 2018-01-03 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:59,474 - __main__ - INFO - Finished processing 2018-01-30 15:00:00 4 hr time horizon... +2026-04-29 10:19:59,481 - __main__ - INFO - Finished processing 2018-01-17 13:00:00 1 hr time horizon... +2026-04-29 10:19:59,500 - __main__ - INFO - Processing values: 2018-01-29 03:00:00 8 hr time horizon... +2026-04-29 10:19:59,504 - __main__ - INFO - Processing values: 2018-01-06 19:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:19:59,588 - __main__ - INFO - Finished processing 2018-01-22 03:00:00 6 hr time horizon... +2026-04-29 10:19:59,611 - __main__ - INFO - Processing values: 2018-01-24 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:00,062 - __main__ - INFO - Finished processing 2018-01-13 10:00:00 8 hr time horizon... +2026-04-29 10:20:00,080 - __main__ - INFO - Processing values: 2018-01-07 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:00,800 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 14 hr time horizon... +2026-04-29 10:20:00,827 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:01,430 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 1 hr time horizon... +2026-04-29 10:20:01,452 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 18 hr time horizon... +2026-04-29 10:20:01,651 - __main__ - INFO - Finished processing 2018-01-09 05:00:00 2 hr time horizon... +2026-04-29 10:20:01,678 - __main__ - INFO - Processing values: 2018-01-02 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:03,113 - __main__ - INFO - Finished processing 2018-01-05 19:00:00 12 hr time horizon... +2026-04-29 10:20:03,135 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:05,777 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 12 hr time horizon... +2026-04-29 10:20:05,800 - __main__ - INFO - Processing values: 2018-01-13 07:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:06,267 - __main__ - INFO - Finished processing 2018-01-21 11:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:06,292 - __main__ - INFO - Processing values: 2018-01-28 16:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:09,103 - __main__ - INFO - Finished processing 2018-01-30 22:00:00 12 hr time horizon... +2026-04-29 10:20:09,125 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:09,349 - __main__ - INFO - Finished processing 2018-01-15 03:00:00 2 hr time horizon... +2026-04-29 10:20:09,369 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 18 hr time horizon... +2026-04-29 10:20:09,405 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:09,429 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:10,327 - __main__ - INFO - Finished processing 2018-01-28 23:00:00 6 hr time horizon... +2026-04-29 10:20:10,348 - __main__ - INFO - Processing values: 2018-01-23 00:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:11,227 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 17 hr time horizon... +2026-04-29 10:20:11,252 - __main__ - INFO - Processing values: 2018-01-25 22:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:12,131 - __main__ - INFO - Finished processing 2018-01-06 04:00:00 6 hr time horizon... +2026-04-29 10:20:12,155 - __main__ - INFO - Processing values: 2018-01-13 04:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:13,092 - __main__ - INFO - Finished processing 2018-01-27 17:00:00 14 hr time horizon... +2026-04-29 10:20:13,121 - __main__ - INFO - Processing values: 2018-01-07 00:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:13,650 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:13,676 - __main__ - INFO - Processing values: 2018-01-08 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:13,975 - __main__ - INFO - Finished processing 2018-01-24 09:00:00 1 hr time horizon... +2026-04-29 10:20:14,001 - __main__ - INFO - Processing values: 2018-01-06 00:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:15,119 - __main__ - INFO - Finished processing 2018-01-06 19:00:00 13 hr time horizon... +2026-04-29 10:20:15,151 - __main__ - INFO - Processing values: 2018-01-01 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:15,818 - __main__ - INFO - Finished processing 2018-01-03 14:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:15,841 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:16,429 - __main__ - INFO - Finished processing 2018-01-07 21:00:00 12 hr time horizon... +2026-04-29 10:20:16,457 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:16,595 - __main__ - INFO - Finished processing 2018-01-15 04:00:00 10 hr time horizon... +2026-04-29 10:20:16,618 - __main__ - INFO - Processing values: 2018-01-18 04:00:00 6 hr time horizon... +2026-04-29 10:20:16,835 - __main__ - INFO - Finished processing 2018-01-02 17:00:00 5 hr time horizon... +2026-04-29 10:20:16,866 - __main__ - INFO - Processing values: 2018-01-08 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:16,989 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 18 hr time horizon... +2026-04-29 10:20:17,013 - __main__ - INFO - Processing values: 2018-01-19 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:17,915 - __main__ - INFO - Finished processing 2018-01-29 03:00:00 8 hr time horizon... +2026-04-29 10:20:17,939 - __main__ - INFO - Processing values: 2018-01-24 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:18,631 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 8 hr time horizon... +2026-04-29 10:20:18,653 - __main__ - INFO - Processing values: 2018-01-26 12:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:21,568 - __main__ - INFO - Finished processing 2018-01-28 16:00:00 1 hr time horizon... +2026-04-29 10:20:21,589 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:21,823 - __main__ - INFO - Finished processing 2018-01-13 07:00:00 8 hr time horizon... +2026-04-29 10:20:21,847 - __main__ - INFO - Processing values: 2018-01-15 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:23,972 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 18 hr time horizon... +2026-04-29 10:20:23,993 - __main__ - INFO - Processing values: 2018-01-02 22:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:24,722 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 5 hr time horizon... +2026-04-29 10:20:24,744 - __main__ - INFO - Processing values: 2018-01-06 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:24,974 - __main__ - INFO - Finished processing 2018-01-25 22:00:00 4 hr time horizon... +2026-04-29 10:20:24,992 - __main__ - INFO - Processing values: 2018-01-15 18:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:25,310 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 13 hr time horizon... +2026-04-29 10:20:25,338 - __main__ - INFO - Processing values: 2018-01-11 04:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:26,272 - __main__ - INFO - Finished processing 2018-01-23 00:00:00 8 hr time horizon... +2026-04-29 10:20:26,295 - __main__ - INFO - Processing values: 2018-01-01 11:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:27,443 - __main__ - INFO - Finished processing 2018-01-13 04:00:00 18 hr time horizon... +2026-04-29 10:20:27,473 - __main__ - INFO - Processing values: 2018-01-03 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:28,526 - __main__ - INFO - Finished processing 2018-01-07 00:00:00 11 hr time horizon... +2026-04-29 10:20:28,554 - __main__ - INFO - Processing values: 2018-01-06 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:29,202 - __main__ - INFO - Finished processing 2018-01-06 00:00:00 3 hr time horizon... +2026-04-29 10:20:29,221 - __main__ - INFO - Processing values: 2018-01-14 07:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:29,511 - __main__ - INFO - Finished processing 2018-01-08 19:00:00 14 hr time horizon... +2026-04-29 10:20:29,535 - __main__ - INFO - Processing values: 2018-01-09 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:30,208 - __main__ - INFO - Finished processing 2018-01-01 09:00:00 15 hr time horizon... +2026-04-29 10:20:30,235 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:30,801 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 7 hr time horizon... +2026-04-29 10:20:30,823 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:31,785 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 2 hr time horizon... +2026-04-29 10:20:31,808 - __main__ - INFO - Processing values: 2018-01-18 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:32,133 - __main__ - INFO - Finished processing 2018-01-19 10:00:00 2 hr time horizon... +2026-04-29 10:20:32,154 - __main__ - INFO - Processing values: 2018-01-25 16:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:32,317 - __main__ - INFO - Finished processing 2018-01-08 07:00:00 4 hr time horizon... +2026-04-29 10:20:32,346 - __main__ - INFO - Processing values: 2018-01-01 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:33,518 - __main__ - INFO - Finished processing 2018-01-18 04:00:00 6 hr time horizon... +2026-04-29 10:20:33,547 - __main__ - INFO - Processing values: 2018-01-25 05:00:00 16 hr time horizon... +2026-04-29 10:20:33,655 - __main__ - INFO - Finished processing 2018-01-24 14:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:33,676 - __main__ - INFO - Processing values: 2018-01-26 11:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:34,302 - __main__ - INFO - Finished processing 2018-01-26 12:00:00 4 hr time horizon... +2026-04-29 10:20:34,324 - __main__ - INFO - Processing values: 2018-01-25 19:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:36,619 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 1 hr time horizon... +2026-04-29 10:20:36,643 - __main__ - INFO - Processing values: 2018-01-19 00:00:00 13 hr time horizon... +2026-04-29 10:20:36,819 - __main__ - INFO - Finished processing 2018-01-15 22:00:00 15 hr time horizon... +2026-04-29 10:20:36,842 - __main__ - INFO - Processing values: 2018-01-07 14:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:39,267 - __main__ - INFO - Finished processing 2018-01-02 22:00:00 15 hr time horizon... +2026-04-29 10:20:39,292 - __main__ - INFO - Processing values: 2018-01-02 13:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:40,657 - __main__ - INFO - Finished processing 2018-01-15 18:00:00 4 hr time horizon... +2026-04-29 10:20:40,682 - __main__ - INFO - Processing values: 2018-01-21 11:00:00 15 hr time horizon... +2026-04-29 10:20:40,689 - __main__ - INFO - Finished processing 2018-01-06 01:00:00 15 hr time horizon... +2026-04-29 10:20:40,711 - __main__ - INFO - Processing values: 2018-01-17 16:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:40,868 - __main__ - INFO - Finished processing 2018-01-11 04:00:00 7 hr time horizon... +2026-04-29 10:20:40,892 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:41,976 - __main__ - INFO - Finished processing 2018-01-01 11:00:00 15 hr time horizon... +2026-04-29 10:20:42,003 - __main__ - INFO - Processing values: 2018-01-10 10:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:42,248 - __main__ - INFO - Finished processing 2018-01-03 08:00:00 1 hr time horizon... +2026-04-29 10:20:42,268 - __main__ - INFO - Processing values: 2018-01-20 02:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:43,754 - __main__ - INFO - Finished processing 2018-01-06 14:00:00 17 hr time horizon... +2026-04-29 10:20:43,784 - __main__ - INFO - Processing values: 2018-01-06 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:44,791 - __main__ - INFO - Finished processing 2018-01-14 07:00:00 13 hr time horizon... +2026-04-29 10:20:44,810 - __main__ - INFO - Processing values: 2018-01-08 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:45,266 - __main__ - INFO - Finished processing 2018-01-09 18:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:45,290 - __main__ - INFO - Processing values: 2018-01-02 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:46,643 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 11 hr time horizon... +2026-04-29 10:20:46,667 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:46,855 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 9 hr time horizon... +2026-04-29 10:20:46,883 - __main__ - INFO - Processing values: 2018-01-03 04:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:47,011 - __main__ - INFO - Finished processing 2018-01-01 10:00:00 8 hr time horizon... +2026-04-29 10:20:47,032 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:47,169 - __main__ - INFO - Finished processing 2018-01-18 00:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:47,203 - __main__ - INFO - Processing values: 2018-01-09 04:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:47,834 - __main__ - INFO - Finished processing 2018-01-25 16:00:00 4 hr time horizon... +2026-04-29 10:20:47,859 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:49,687 - __main__ - INFO - Finished processing 2018-01-25 05:00:00 16 hr time horizon... +2026-04-29 10:20:49,710 - __main__ - INFO - Processing values: 2018-01-27 18:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:49,868 - __main__ - INFO - Finished processing 2018-01-25 19:00:00 15 hr time horizon... +2026-04-29 10:20:49,893 - __main__ - INFO - Processing values: 2018-01-14 18:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:50,193 - __main__ - INFO - Finished processing 2018-01-26 11:00:00 4 hr time horizon... +2026-04-29 10:20:50,211 - __main__ - INFO - Processing values: 2018-01-27 12:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:52,827 - __main__ - INFO - Finished processing 2018-01-19 00:00:00 13 hr time horizon... +2026-04-29 10:20:52,860 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:52,920 - __main__ - INFO - Finished processing 2018-01-07 14:00:00 2 hr time horizon... +2026-04-29 10:20:52,950 - __main__ - INFO - Processing values: 2018-01-21 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:54,489 - __main__ - INFO - Finished processing 2018-01-02 13:00:00 3 hr time horizon... +2026-04-29 10:20:54,513 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:55,932 - __main__ - INFO - Finished processing 2018-01-17 16:00:00 15 hr time horizon... +2026-04-29 10:20:55,953 - __main__ - INFO - Processing values: 2018-01-25 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:56,073 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 6 hr time horizon... +2026-04-29 10:20:56,095 - __main__ - INFO - Processing values: 2018-01-12 23:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:56,285 - __main__ - INFO - Finished processing 2018-01-21 11:00:00 15 hr time horizon... +2026-04-29 10:20:56,307 - __main__ - INFO - Processing values: 2018-01-24 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:58,180 - __main__ - INFO - Finished processing 2018-01-20 02:00:00 14 hr time horizon... +2026-04-29 10:20:58,203 - __main__ - INFO - Processing values: 2018-01-27 01:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:58,672 - __main__ - INFO - Finished processing 2018-01-06 13:00:00 16 hr time horizon... +2026-04-29 10:20:58,701 - __main__ - INFO - Processing values: 2018-01-05 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:59,238 - __main__ - INFO - Finished processing 2018-01-10 10:00:00 12 hr time horizon... +2026-04-29 10:20:59,262 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:59,824 - __main__ - INFO - Finished processing 2018-01-08 09:00:00 2 hr time horizon... +2026-04-29 10:20:59,846 - __main__ - INFO - Processing values: 2018-01-12 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:59,970 - __main__ - INFO - Finished processing 2018-01-02 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:20:59,993 - __main__ - INFO - Processing values: 2018-01-08 12:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:01,464 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 1 hr time horizon... +2026-04-29 10:21:01,483 - __main__ - INFO - Processing values: 2018-01-30 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:02,261 - __main__ - INFO - Finished processing 2018-01-03 04:00:00 6 hr time horizon... +2026-04-29 10:21:02,282 - __main__ - INFO - Processing values: 2018-01-24 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:02,398 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 10 hr time horizon... +2026-04-29 10:21:02,418 - __main__ - INFO - Processing values: 2018-01-29 16:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:02,614 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 12 hr time horizon... +2026-04-29 10:21:02,638 - __main__ - INFO - Processing values: 2018-01-20 19:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:03,200 - __main__ - INFO - Finished processing 2018-01-09 04:00:00 13 hr time horizon... +2026-04-29 10:21:03,227 - __main__ - INFO - Processing values: 2018-01-17 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:03,778 - __main__ - INFO - Finished processing 2018-01-14 18:00:00 2 hr time horizon... +2026-04-29 10:21:03,800 - __main__ - INFO - Processing values: 2018-01-12 17:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:05,299 - __main__ - INFO - Finished processing 2018-01-27 18:00:00 13 hr time horizon... +2026-04-29 10:21:05,321 - __main__ - INFO - Processing values: 2018-01-15 10:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:06,109 - __main__ - INFO - Finished processing 2018-01-27 12:00:00 7 hr time horizon... +2026-04-29 10:21:06,134 - __main__ - INFO - Processing values: 2018-01-27 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:08,177 - __main__ - INFO - Finished processing 2018-01-21 13:00:00 4 hr time horizon... +2026-04-29 10:21:08,202 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:08,675 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:08,700 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:10,122 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 17 hr time horizon... +2026-04-29 10:21:10,152 - __main__ - INFO - Processing values: 2018-01-02 01:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:11,023 - __main__ - INFO - Finished processing 2018-01-12 23:00:00 16 hr time horizon... +2026-04-29 10:21:11,048 - __main__ - INFO - Processing values: 2018-01-11 16:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:11,269 - __main__ - INFO - Finished processing 2018-01-25 23:00:00 13 hr time horizon... +2026-04-29 10:21:11,292 - __main__ - INFO - Processing values: 2018-01-04 15:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:11,863 - __main__ - INFO - Finished processing 2018-01-24 00:00:00 17 hr time horizon... +2026-04-29 10:21:11,887 - __main__ - INFO - Processing values: 2018-01-10 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:13,726 - __main__ - INFO - Finished processing 2018-01-05 05:00:00 5 hr time horizon... +2026-04-29 10:21:13,749 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:14,157 - __main__ - INFO - Finished processing 2018-01-27 01:00:00 13 hr time horizon... +2026-04-29 10:21:14,181 - __main__ - INFO - Processing values: 2018-01-30 17:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:14,774 - __main__ - INFO - Finished processing 2018-01-12 13:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:14,799 - __main__ - INFO - Processing values: 2018-01-26 22:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:15,312 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:15,339 - __main__ - INFO - Processing values: 2018-01-15 00:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:17,439 - __main__ - INFO - Finished processing 2018-01-30 02:00:00 13 hr time horizon... +2026-04-29 10:21:17,461 - __main__ - INFO - Processing values: 2018-01-06 21:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:17,645 - __main__ - INFO - Finished processing 2018-01-29 16:00:00 14 hr time horizon... +2026-04-29 10:21:17,671 - __main__ - INFO - Processing values: 2018-01-18 12:00:00 14 hr time horizon... +2026-04-29 10:21:17,734 - __main__ - INFO - Finished processing 2018-01-24 13:00:00 16 hr time horizon... +2026-04-29 10:21:17,754 - __main__ - INFO - Processing values: 2018-01-24 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:18,050 - __main__ - INFO - Finished processing 2018-01-20 19:00:00 14 hr time horizon... +2026-04-29 10:21:18,073 - __main__ - INFO - Processing values: 2018-01-07 10:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:18,622 - __main__ - INFO - Finished processing 2018-01-08 12:00:00 9 hr time horizon... +2026-04-29 10:21:18,648 - __main__ - INFO - Processing values: 2018-01-14 13:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:18,798 - __main__ - INFO - Finished processing 2018-01-17 06:00:00 4 hr time horizon... +2026-04-29 10:21:18,820 - __main__ - INFO - Processing values: 2018-01-11 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:19,122 - __main__ - INFO - Finished processing 2018-01-12 17:00:00 17 hr time horizon... +2026-04-29 10:21:19,143 - __main__ - INFO - Processing values: 2018-01-01 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:21,374 - __main__ - INFO - Finished processing 2018-01-15 10:00:00 8 hr time horizon... +2026-04-29 10:21:21,397 - __main__ - INFO - Processing values: 2018-01-07 06:00:00 12 hr time horizon... +2026-04-29 10:21:21,414 - __main__ - INFO - Finished processing 2018-01-27 15:00:00 7 hr time horizon... +2026-04-29 10:21:21,440 - __main__ - INFO - Processing values: 2018-01-13 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:23,860 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:23,880 - __main__ - INFO - Processing values: 2018-01-07 19:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:24,601 - __main__ - INFO - Finished processing 2018-01-10 02:00:00 15 hr time horizon... +2026-04-29 10:21:24,626 - __main__ - INFO - Processing values: 2018-01-10 21:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:25,666 - __main__ - INFO - Finished processing 2018-01-02 01:00:00 9 hr time horizon... +2026-04-29 10:21:25,689 - __main__ - INFO - Processing values: 2018-01-22 20:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:26,560 - __main__ - INFO - Finished processing 2018-01-04 15:00:00 7 hr time horizon... +2026-04-29 10:21:26,580 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:27,125 - __main__ - INFO - Finished processing 2018-01-11 16:00:00 12 hr time horizon... +2026-04-29 10:21:27,147 - __main__ - INFO - Processing values: 2018-01-07 03:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:28,500 - __main__ - INFO - Finished processing 2018-01-10 03:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:21:28,525 - __main__ - INFO - Processing values: 2018-01-11 01:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:29,519 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 3 hr time horizon... +2026-04-29 10:21:29,542 - __main__ - INFO - Processing values: 2018-01-21 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:29,685 - __main__ - INFO - Finished processing 2018-01-30 17:00:00 12 hr time horizon... +2026-04-29 10:21:29,707 - __main__ - INFO - Processing values: 2018-01-15 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:29,943 - __main__ - INFO - Finished processing 2018-01-26 22:00:00 11 hr time horizon... +2026-04-29 10:21:29,961 - __main__ - INFO - Processing values: 2018-01-24 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:30,242 - __main__ - INFO - Finished processing 2018-01-15 00:00:00 17 hr time horizon... +2026-04-29 10:21:30,268 - __main__ - INFO - Processing values: 2018-01-06 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:31,891 - __main__ - INFO - Finished processing 2018-01-24 01:00:00 6 hr time horizon... +2026-04-29 10:21:31,911 - __main__ - INFO - Processing values: 2018-01-21 09:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:32,021 - __main__ - INFO - Finished processing 2018-01-06 21:00:00 8 hr time horizon... +2026-04-29 10:21:32,042 - __main__ - INFO - Processing values: 2018-01-02 14:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:33,400 - __main__ - INFO - Finished processing 2018-01-18 12:00:00 14 hr time horizon... +2026-04-29 10:21:33,420 - __main__ - INFO - Processing values: 2018-01-03 18:00:00 13 hr time horizon... +2026-04-29 10:21:33,433 - __main__ - INFO - Finished processing 2018-01-14 13:00:00 4 hr time horizon... +2026-04-29 10:21:33,454 - __main__ - INFO - Processing values: 2018-01-14 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:33,568 - __main__ - INFO - Finished processing 2018-01-01 21:00:00 12 hr time horizon... +2026-04-29 10:21:33,591 - __main__ - INFO - Processing values: 2018-01-03 15:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:33,864 - __main__ - INFO - Finished processing 2018-01-11 05:00:00 17 hr time horizon... +2026-04-29 10:21:33,890 - __main__ - INFO - Processing values: 2018-01-08 17:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:35,998 - __main__ - INFO - Finished processing 2018-01-07 10:00:00 15 hr time horizon... +2026-04-29 10:21:36,021 - __main__ - INFO - Processing values: 2018-01-05 22:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:36,404 - __main__ - INFO - Finished processing 2018-01-07 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:36,428 - __main__ - INFO - Processing values: 2018-01-11 15:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:36,974 - __main__ - INFO - Finished processing 2018-01-13 14:00:00 18 hr time horizon... +2026-04-29 10:21:36,993 - __main__ - INFO - Processing values: 2018-01-26 09:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:38,955 - __main__ - INFO - Finished processing 2018-01-10 21:00:00 14 hr time horizon... +2026-04-29 10:21:38,978 - __main__ - INFO - Processing values: 2018-01-01 18:00:00 8 hr time horizon... +2026-04-29 10:21:39,181 - __main__ - INFO - Finished processing 2018-01-22 20:00:00 13 hr time horizon... +2026-04-29 10:21:39,201 - __main__ - INFO - Processing values: 2018-01-11 20:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:40,622 - __main__ - INFO - Finished processing 2018-01-07 03:00:00 2 hr time horizon... +2026-04-29 10:21:40,643 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:43,113 - __main__ - INFO - Finished processing 2018-01-24 16:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:43,134 - __main__ - INFO - Processing values: 2018-01-19 06:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:43,611 - __main__ - INFO - Finished processing 2018-01-21 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:43,631 - __main__ - INFO - Processing values: 2018-01-29 17:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:43,760 - __main__ - INFO - Finished processing 2018-01-15 09:00:00 3 hr time horizon... +2026-04-29 10:21:43,779 - __main__ - INFO - Processing values: 2018-01-23 07:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:44,402 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 14 hr time horizon... +2026-04-29 10:21:44,423 - __main__ - INFO - Processing values: 2018-01-19 13:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:45,005 - __main__ - INFO - Finished processing 2018-01-06 02:00:00 13 hr time horizon... +2026-04-29 10:21:45,036 - __main__ - INFO - Processing values: 2018-01-26 07:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:46,011 - __main__ - INFO - Finished processing 2018-01-11 01:00:00 15 hr time horizon... +2026-04-29 10:21:46,036 - __main__ - INFO - Processing values: 2018-01-19 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:46,197 - __main__ - INFO - Finished processing 2018-01-02 14:00:00 10 hr time horizon... +2026-04-29 10:21:46,221 - __main__ - INFO - Processing values: 2018-01-20 07:00:00 5 hr time horizon... +2026-04-29 10:21:46,313 - __main__ - INFO - Finished processing 2018-01-21 09:00:00 1 hr time horizon... +2026-04-29 10:21:46,332 - __main__ - INFO - Processing values: 2018-01-18 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:47,351 - __main__ - INFO - Finished processing 2018-01-03 18:00:00 13 hr time horizon... +2026-04-29 10:21:47,372 - __main__ - INFO - Processing values: 2018-01-27 14:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:47,575 - __main__ - INFO - Finished processing 2018-01-03 15:00:00 9 hr time horizon... +2026-04-29 10:21:47,596 - __main__ - INFO - Processing values: 2018-01-10 14:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:48,491 - __main__ - INFO - Finished processing 2018-01-08 17:00:00 8 hr time horizon... +2026-04-29 10:21:48,522 - __main__ - INFO - Processing values: 2018-01-26 17:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:49,364 - __main__ - INFO - Finished processing 2018-01-05 22:00:00 7 hr time horizon... +2026-04-29 10:21:49,387 - __main__ - INFO - Processing values: 2018-01-03 03:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:50,345 - __main__ - INFO - Finished processing 2018-01-11 15:00:00 10 hr time horizon... +2026-04-29 10:21:50,368 - __main__ - INFO - Processing values: 2018-01-28 05:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:50,689 - __main__ - INFO - Finished processing 2018-01-26 09:00:00 7 hr time horizon... +2026-04-29 10:21:50,714 - __main__ - INFO - Processing values: 2018-01-28 21:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:53,118 - __main__ - INFO - Finished processing 2018-01-01 18:00:00 8 hr time horizon... +2026-04-29 10:21:53,137 - __main__ - INFO - Processing values: 2018-01-24 21:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:53,445 - __main__ - INFO - Finished processing 2018-01-07 19:00:00 11 hr time horizon... +2026-04-29 10:21:53,469 - __main__ - INFO - Processing values: 2018-01-30 07:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:55,064 - __main__ - INFO - Finished processing 2018-01-11 20:00:00 3 hr time horizon... +2026-04-29 10:21:55,090 - __main__ - INFO - Processing values: 2018-01-07 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:55,130 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 18 hr time horizon... +2026-04-29 10:21:55,152 - __main__ - INFO - Processing values: 2018-01-24 07:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:57,958 - __main__ - INFO - Finished processing 2018-01-19 06:00:00 8 hr time horizon... +2026-04-29 10:21:57,984 - __main__ - INFO - Processing values: 2018-01-16 19:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:58,266 - __main__ - INFO - Finished processing 2018-01-29 17:00:00 18 hr time horizon... +2026-04-29 10:21:58,287 - __main__ - INFO - Processing values: 2018-01-13 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:58,619 - __main__ - INFO - Finished processing 2018-01-23 07:00:00 17 hr time horizon... +2026-04-29 10:21:58,643 - __main__ - INFO - Processing values: 2018-01-04 08:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:21:59,619 - __main__ - INFO - Finished processing 2018-01-19 13:00:00 15 hr time horizon... +2026-04-29 10:21:59,651 - __main__ - INFO - Processing values: 2018-01-06 09:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:00,113 - __main__ - INFO - Finished processing 2018-01-26 07:00:00 2 hr time horizon... +2026-04-29 10:22:00,134 - __main__ - INFO - Processing values: 2018-01-07 22:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:00,618 - __main__ - INFO - Finished processing 2018-01-19 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:00,640 - __main__ - INFO - Processing values: 2018-01-09 03:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:01,247 - __main__ - INFO - Finished processing 2018-01-20 07:00:00 5 hr time horizon... +2026-04-29 10:22:01,270 - __main__ - INFO - Processing values: 2018-01-17 07:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:01,739 - __main__ - INFO - Finished processing 2018-01-18 17:00:00 14 hr time horizon... +2026-04-29 10:22:01,761 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 4 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +2026-04-29 10:22:01,832 - __main__ - INFO - Finished processing 2018-01-14 05:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:01,861 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:02,320 - __main__ - INFO - Finished processing 2018-01-27 14:00:00 8 hr time horizon... +2026-04-29 10:22:02,341 - __main__ - INFO - Processing values: 2018-01-17 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:03,678 - __main__ - INFO - Finished processing 2018-01-10 14:00:00 18 hr time horizon... +2026-04-29 10:22:03,702 - __main__ - INFO - Processing values: 2018-01-20 03:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:04,045 - __main__ - INFO - Finished processing 2018-01-26 17:00:00 14 hr time horizon... +2026-04-29 10:22:04,068 - __main__ - INFO - Processing values: 2018-01-26 06:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:04,981 - __main__ - INFO - Finished processing 2018-01-03 03:00:00 15 hr time horizon... +2026-04-29 10:22:05,003 - __main__ - INFO - Processing values: 2018-01-23 01:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:05,543 - __main__ - INFO - Finished processing 2018-01-28 05:00:00 18 hr time horizon... +2026-04-29 10:22:05,572 - __main__ - INFO - Processing values: 2018-01-29 07:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:05,796 - __main__ - INFO - Finished processing 2018-01-28 21:00:00 18 hr time horizon... +2026-04-29 10:22:05,821 - __main__ - INFO - Processing values: 2018-01-26 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:07,730 - __main__ - INFO - Finished processing 2018-01-24 21:00:00 12 hr time horizon... +2026-04-29 10:22:07,751 - __main__ - INFO - Processing values: 2018-01-05 13:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:09,115 - __main__ - INFO - Finished processing 2018-01-30 07:00:00 12 hr time horizon... +2026-04-29 10:22:09,137 - __main__ - INFO - Processing values: 2018-01-02 08:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:09,570 - __main__ - INFO - Finished processing 2018-01-24 07:00:00 5 hr time horizon... +2026-04-29 10:22:09,590 - __main__ - INFO - Processing values: 2018-01-24 23:00:00 7 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:10,919 - __main__ - INFO - Finished processing 2018-01-07 09:00:00 15 hr time horizon... +2026-04-29 10:22:10,947 - __main__ - INFO - Processing values: 2018-01-02 03:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:12,411 - __main__ - INFO - Finished processing 2018-01-13 12:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:12,423 - __main__ - INFO - Finished processing 2018-01-16 19:00:00 10 hr time horizon... +2026-04-29 10:22:12,430 - __main__ - INFO - Processing values: 2018-01-04 22:00:00 6 hr time horizon... +2026-04-29 10:22:12,445 - __main__ - INFO - Processing values: 2018-01-30 21:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:13,027 - __main__ - INFO - Finished processing 2018-01-04 08:00:00 4 hr time horizon... +2026-04-29 10:22:13,046 - __main__ - INFO - Processing values: 2018-01-07 15:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:14,257 - __main__ - INFO - Finished processing 2018-01-07 22:00:00 14 hr time horizon... +2026-04-29 10:22:14,282 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:15,574 - __main__ - INFO - Finished processing 2018-01-09 03:00:00 13 hr time horizon... +2026-04-29 10:22:15,597 - __main__ - INFO - Processing values: 2018-01-18 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:16,155 - __main__ - INFO - Finished processing 2018-01-17 07:00:00 4 hr time horizon... +2026-04-29 10:22:16,175 - __main__ - INFO - Processing values: 2018-01-06 05:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:16,352 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 4 hr time horizon... +2026-04-29 10:22:16,369 - __main__ - INFO - Processing values: 2018-01-04 09:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:16,558 - __main__ - INFO - Finished processing 2018-01-06 09:00:00 3 hr time horizon... +2026-04-29 10:22:16,578 - __main__ - INFO - Processing values: 2018-01-13 02:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:17,127 - __main__ - INFO - Finished processing 2018-01-17 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:17,151 - __main__ - INFO - Processing values: 2018-01-25 21:00:00 15 hr time horizon... +2026-04-29 10:22:17,205 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 10 hr time horizon... +2026-04-29 10:22:17,225 - __main__ - INFO - Processing values: 2018-01-20 05:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:19,613 - __main__ - INFO - Finished processing 2018-01-26 06:00:00 16 hr time horizon... +2026-04-29 10:22:19,635 - __main__ - INFO - Processing values: 2018-01-29 18:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:19,698 - __main__ - INFO - Finished processing 2018-01-23 01:00:00 2 hr time horizon... +2026-04-29 10:22:19,716 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:20,167 - __main__ - INFO - Finished processing 2018-01-26 01:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:20,185 - __main__ - INFO - Processing values: 2018-01-07 18:00:00 1 hr time horizon... +2026-04-29 10:22:20,247 - __main__ - INFO - Finished processing 2018-01-29 07:00:00 11 hr time horizon... +2026-04-29 10:22:20,265 - __main__ - INFO - Processing values: 2018-01-18 14:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:20,903 - __main__ - INFO - Finished processing 2018-01-20 03:00:00 16 hr time horizon... +2026-04-29 10:22:20,924 - __main__ - INFO - Processing values: 2018-01-06 06:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:22,075 - __main__ - INFO - Finished processing 2018-01-05 13:00:00 11 hr time horizon... +2026-04-29 10:22:22,096 - __main__ - INFO - Processing values: 2018-01-01 23:00:00 9 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:25,259 - __main__ - INFO - Finished processing 2018-01-24 23:00:00 7 hr time horizon... +2026-04-29 10:22:25,275 - __main__ - INFO - Processing values: 2018-01-23 21:00:00 9 hr time horizon... +2026-04-29 10:22:25,522 - __main__ - INFO - Finished processing 2018-01-04 22:00:00 6 hr time horizon... +2026-04-29 10:22:25,538 - __main__ - INFO - Processing values: 2018-01-26 08:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:32,770 - __main__ - INFO - Finished processing 2018-01-25 21:00:00 15 hr time horizon... +2026-04-29 10:22:32,787 - __main__ - INFO - Processing values: 2018-01-11 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:37,927 - __main__ - INFO - Finished processing 2018-01-23 21:00:00 9 hr time horizon... +2026-04-29 10:22:37,948 - __main__ - INFO - Processing values: 2018-01-27 05:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:38,392 - __main__ - INFO - Finished processing 2018-01-26 08:00:00 13 hr time horizon... +2026-04-29 10:22:38,412 - __main__ - INFO - Processing values: 2018-01-14 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:38,749 - __main__ - INFO - Finished processing 2018-01-29 10:00:00 2 hr time horizon... +2026-04-29 10:22:38,765 - __main__ - INFO - Processing values: 2018-01-23 14:00:00 3 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:39,832 - __main__ - INFO - Finished processing 2018-01-29 18:00:00 11 hr time horizon... +2026-04-29 10:22:39,850 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:47,096 - __main__ - INFO - Finished processing 2018-01-30 21:00:00 10 hr time horizon... +2026-04-29 10:22:47,113 - __main__ - INFO - Processing values: 2018-01-08 01:00:00 17 hr time horizon... +2026-04-29 10:22:47,338 - __main__ - INFO - Finished processing 2018-01-11 19:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:47,360 - __main__ - INFO - Processing values: 2018-01-16 17:00:00 18 hr time horizon... +2026-04-29 10:22:47,645 - __main__ - INFO - Finished processing 2018-01-13 02:00:00 11 hr time horizon... +2026-04-29 10:22:47,671 - __main__ - INFO - Processing values: 2018-01-15 19:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:49,971 - __main__ - INFO - Finished processing 2018-01-02 08:00:00 10 hr time horizon... +2026-04-29 10:22:49,988 - __main__ - INFO - Processing values: 2018-01-20 04:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:51,109 - __main__ - INFO - Finished processing 2018-01-27 05:00:00 11 hr time horizon... +2026-04-29 10:22:51,129 - __main__ - INFO - Processing values: 2018-01-19 22:00:00 2 hr time horizon... +2026-04-29 10:22:51,133 - __main__ - INFO - Finished processing 2018-01-18 20:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:51,155 - __main__ - INFO - Processing values: 2018-01-27 08:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:52,306 - __main__ - INFO - Finished processing 2018-01-14 06:00:00 5 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:52,324 - __main__ - INFO - Processing values: 2018-01-07 04:00:00 1 hr time horizon... +2026-04-29 10:22:52,404 - __main__ - INFO - Finished processing 2018-01-23 14:00:00 3 hr time horizon... +2026-04-29 10:22:52,422 - __main__ - INFO - Processing values: 2018-01-19 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:22:53,195 - __main__ - INFO - Finished processing 2018-01-23 08:00:00 17 hr time horizon... +2026-04-29 10:22:53,214 - __main__ - INFO - Processing values: 2018-01-30 18:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:00,456 - __main__ - INFO - Finished processing 2018-01-16 17:00:00 18 hr time horizon... +2026-04-29 10:23:00,473 - __main__ - INFO - Processing values: 2018-01-16 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:01,617 - __main__ - INFO - Finished processing 2018-01-08 01:00:00 17 hr time horizon... +2026-04-29 10:23:01,642 - __main__ - INFO - Processing values: 2018-01-27 20:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:02,188 - __main__ - INFO - Finished processing 2018-01-15 19:00:00 16 hr time horizon... +2026-04-29 10:23:02,205 - __main__ - INFO - Processing values: 2018-01-09 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:02,309 - __main__ - INFO - Finished processing 2018-01-06 06:00:00 12 hr time horizon... +2026-04-29 10:23:02,331 - __main__ - INFO - Processing values: 2018-01-17 05:00:00 12 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:03,917 - __main__ - INFO - Finished processing 2018-01-19 22:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:03,940 - __main__ - INFO - Processing values: 2018-01-14 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:04,443 - __main__ - INFO - Finished processing 2018-01-27 08:00:00 15 hr time horizon... +2026-04-29 10:23:04,465 - __main__ - INFO - Processing values: 2018-01-22 23:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:04,611 - __main__ - INFO - Finished processing 2018-01-20 04:00:00 8 hr time horizon... +2026-04-29 10:23:04,632 - __main__ - INFO - Processing values: 2018-01-25 17:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:05,119 - __main__ - INFO - Finished processing 2018-01-19 03:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:05,141 - __main__ - INFO - Processing values: 2018-01-05 10:00:00 14 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:05,874 - __main__ - INFO - Finished processing 2018-01-30 18:00:00 1 hr time horizon... +2026-04-29 10:23:05,891 - __main__ - INFO - Processing values: 2018-01-04 10:00:00 17 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:07,071 - __main__ - INFO - Finished processing 2018-01-07 04:00:00 1 hr time horizon... +2026-04-29 10:23:07,091 - __main__ - INFO - Processing values: 2018-01-26 23:00:00 18 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:13,184 - __main__ - INFO - Finished processing 2018-01-16 02:00:00 13 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:13,203 - __main__ - INFO - Processing values: 2018-01-17 09:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:15,300 - __main__ - INFO - Finished processing 2018-01-17 05:00:00 12 hr time horizon... +2026-04-29 10:23:15,319 - __main__ - INFO - Processing values: 2018-01-14 21:00:00 15 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:16,025 - __main__ - INFO - Finished processing 2018-01-09 09:00:00 8 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:16,049 - __main__ - INFO - Processing values: 2018-01-17 09:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:16,646 - __main__ - INFO - Finished processing 2018-01-14 23:00:00 13 hr time horizon... +2026-04-29 10:23:16,665 - __main__ - INFO - Processing values: 2018-01-15 04:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:17,395 - __main__ - INFO - Finished processing 2018-01-25 17:00:00 13 hr time horizon... +2026-04-29 10:23:17,420 - __main__ - INFO - Processing values: 2018-01-19 01:00:00 11 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:17,460 - __main__ - INFO - Finished processing 2018-01-27 20:00:00 16 hr time horizon... +2026-04-29 10:23:17,479 - __main__ - INFO - Processing values: 2018-01-29 10:00:00 6 hr time horizon... +2026-04-29 10:23:17,509 - __main__ - INFO - Finished processing 2018-01-22 23:00:00 13 hr time horizon... +2026-04-29 10:23:17,528 - __main__ - INFO - Processing values: 2018-01-29 01:00:00 6 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:18,282 - __main__ - INFO - Finished processing 2018-01-04 10:00:00 17 hr time horizon... +2026-04-29 10:23:18,303 - __main__ - INFO - Processing values: 2018-01-23 08:00:00 10 hr time horizon... +2026-04-29 10:23:18,343 - __main__ - INFO - Finished processing 2018-01-05 10:00:00 14 hr time horizon... +2026-04-29 10:23:18,364 - __main__ - INFO - Processing values: 2018-01-27 21:00:00 2 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:20,599 - __main__ - INFO - Finished processing 2018-01-26 23:00:00 18 hr time horizon... +2026-04-29 10:23:20,628 - __main__ - INFO - Processing values: 2018-01-28 13:00:00 16 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "u". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:23,551 - __main__ - INFO - Finished processing 2018-01-02 03:00:00 8 hr time horizon... +2026-04-29 10:23:23,572 - __main__ - INFO - Processing values: 2018-01-10 08:00:00 1 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "v". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "r2". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "sp". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "t". + ds = ds.metpy.assign_y_x() +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "d2m". + ds = ds.metpy.assign_y_x() +2026-04-29 10:23:25,092 - __main__ - INFO - Finished processing 2018-01-18 14:00:00 13 hr time horizon... +2026-04-29 10:23:25,111 - __main__ - INFO - Processing values: 2018-01-20 10:00:00 8 hr time horizon... +2026-04-29 10:23:25,605 - __main__ - INFO - Finished processing 2018-01-17 09:00:00 2 hr time horizon... +2026-04-29 10:23:25,622 - __main__ - INFO - Processing values: 2018-01-10 02:00:00 10 hr time horizon... +/kfs2/projects/pvfleets24/repos/regrow/data/generate_herbie_forecasts.py:57: DeprecationWarning: The accessor `ds.herbie.nearest_points` is deprecated in favor of the `ds.herbie.pick_points` which uses the BallTree algorithm instead. + dsi = ds.herbie.nearest_points(points=points, +/kfs2/projects/pvfleets24/envs/regrow/lib/python3.12/site-packages/herbie/accessors.py:681: UserWarning: More than one time coordinate present for variable "tcc". + ds = ds.metpy.assign_y_x() +[2026-04-29T10:23:25.821] error: *** JOB 13573894 ON x1002c4s2b1n1 CANCELLED AT 2026-04-29T10:23:25 DUE to SIGNAL Terminated ***